From 4c99af774f00f41e8e6af3ebfe775c60b4402290 Mon Sep 17 00:00:00 2001 From: vms Date: Mon, 10 May 2021 13:50:52 +0300 Subject: [PATCH] renaming --- .circleci/config.yml | 2 +- crates/main/src/module_manifest.rs | 52 +++++++-------- crates/main/src/sdk_version_embedder.rs | 2 +- crates/marine-macro-impl/src/ast_types.rs | 2 +- crates/marine-macro-impl/src/lib.rs | 6 +- ...fce_macro_impl.rs => marine_macro_impl.rs} | 4 +- .../src/parse_macro_input.rs | 8 +-- .../src/parse_macro_input/item_fn.rs | 18 ++--- .../src/parse_macro_input/item_foreign_mod.rs | 8 +-- .../src/parse_macro_input/item_record.rs | 10 +-- .../src/parsed_type/fn_epilog.rs | 4 +- .../src/parsed_type/fn_prolog.rs | 4 +- .../src/parsed_type/foreign_mod_arg.rs | 2 +- .../src/parsed_type/foreign_mod_epilog.rs | 4 +- .../src/parsed_type/foreign_mod_prolog.rs | 2 +- .../src/parsed_type/vector_ser_der/der.rs | 2 +- .../src/parsed_type/vector_ser_der/ser.rs | 2 +- .../src/token_stream_generator.rs | 16 ++--- .../record_generator.rs | 6 +- .../record_generator/field_values_builder.rs | 4 +- .../record_generator/record_serializer.rs | 4 +- crates/marine-macro-impl/src/utils.rs | 6 +- .../exports/arrays/expanded.rs | 38 +++++------ .../exports/arrays/{fce.rs => marine.rs} | 0 .../exports/basic_types/expanded.rs | 14 ++-- .../exports/basic_types/{fce.rs => marine.rs} | 0 .../generation_tests/exports/refs/expanded.rs | 30 ++++----- .../exports/refs/{fce.rs => marine.rs} | 0 .../records/call_parameters/expanded.rs | 28 ++++---- .../call_parameters/{fce.rs => marine.rs} | 0 .../records/use_as_type/expanded.rs | 42 ++++++------ .../records/use_as_type/{fce.rs => marine.rs} | 0 .../tests/generation_tests_runner.rs | 22 +++---- crates/marine-macro-impl/tests/utils.rs | 16 ++--- crates/marine-macro/src/lib.rs | 12 ++-- crates/marine-test-macro-impl/Cargo.toml | 4 +- .../marine-test-macro-impl/src/attributes.rs | 4 +- crates/marine-test-macro-impl/src/errors.rs | 4 +- crates/marine-test-macro-impl/src/lib.rs | 4 +- .../{fce_test => marine_test}/config_utils.rs | 4 +- .../glue_code_generator.rs | 66 +++++++++---------- .../marine_test_impl.rs} | 8 +-- .../src/{fce_test => marine_test}/mod.rs | 4 +- .../module_generator.rs | 26 ++++---- .../module_generator/methods_generator.rs | 8 +-- .../methods_generator_utils.rs | 34 +++++----- .../module_generator/record_type_generator.rs | 10 +-- .../src/{fce_test => marine_test}/utils.rs | 10 +-- crates/marine-test-macro/src/lib.rs | 8 +-- crates/timestamp-macro/src/lib.rs | 2 +- fluence-test/Cargo.toml | 2 +- fluence-test/src/lib.rs | 4 +- fluence/src/call_parameters.rs | 2 +- fluence/src/lib.rs | 20 +++--- .../export_functions/array_inner_refs.rs | 14 ++-- .../export_functions/arrays.rs | 28 ++++---- .../export_functions/basic_types.rs | 26 ++++---- .../export_functions/improper_types.rs | 12 ++-- .../export_functions/inner_vec_refs.rs | 4 +- .../export_functions/inner_vec_refs.stderr | 10 +-- .../export_functions/ref_arrays.rs | 28 ++++---- .../export_functions/ref_basic_types.rs | 24 +++---- .../import_functions/arrays.rs | 6 +- .../import_functions/arrays_out_inner_refs.rs | 16 ++--- .../arrays_out_inner_refs.stderr | 2 +- .../import_functions/basic_ref_types.rs | 4 +- .../import_functions/basic_types.rs | 4 +- .../import_functions/improper_types.rs | 14 ++-- .../import_functions/ref_arrays.rs | 6 +- .../import_functions/ref_basic_types.rs | 4 +- .../records/basic_structs.rs | 18 ++--- .../compilation_tests/records/empty_struct.rs | 4 +- .../records/struct_with_improper_types.rs | 8 +-- .../records/struct_with_private_fields.rs | 4 +- .../records/struct_with_private_fields.stderr | 2 +- .../records/unnamed_structs.rs | 4 +- fluence/tests/compilation_tests_runner.rs | 2 +- 77 files changed, 418 insertions(+), 420 deletions(-) rename crates/marine-macro-impl/src/{fce_macro_impl.rs => marine_macro_impl.rs} (91%) rename crates/marine-macro-impl/tests/generation_tests/exports/arrays/{fce.rs => marine.rs} (100%) rename crates/marine-macro-impl/tests/generation_tests/exports/basic_types/{fce.rs => marine.rs} (100%) rename crates/marine-macro-impl/tests/generation_tests/exports/refs/{fce.rs => marine.rs} (100%) rename crates/marine-macro-impl/tests/generation_tests/records/call_parameters/{fce.rs => marine.rs} (100%) rename crates/marine-macro-impl/tests/generation_tests/records/use_as_type/{fce.rs => marine.rs} (100%) rename crates/marine-test-macro-impl/src/{fce_test => marine_test}/config_utils.rs (96%) rename crates/marine-test-macro-impl/src/{fce_test => marine_test}/glue_code_generator.rs (74%) rename crates/marine-test-macro-impl/src/{fce_test/fce_test_impl.rs => marine_test/marine_test_impl.rs} (86%) rename crates/marine-test-macro-impl/src/{fce_test => marine_test}/mod.rs (91%) rename crates/marine-test-macro-impl/src/{fce_test => marine_test}/module_generator.rs (78%) rename crates/marine-test-macro-impl/src/{fce_test => marine_test}/module_generator/methods_generator.rs (85%) rename crates/marine-test-macro-impl/src/{fce_test => marine_test}/module_generator/methods_generator_utils.rs (86%) rename crates/marine-test-macro-impl/src/{fce_test => marine_test}/module_generator/record_type_generator.rs (87%) rename crates/marine-test-macro-impl/src/{fce_test => marine_test}/utils.rs (87%) diff --git a/.circleci/config.yml b/.circleci/config.yml index d347b2d..2f998c6 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -23,7 +23,7 @@ jobs: (cd fluence; cargo build -v --target wasm32-wasi --all-features) (cd fluence; cargo clippy -v --target wasm32-wasi) (cd fluence-test; cargo build) - (cd crates/wit; cargo test) + (cd crates/marine-macro-impl; cargo test) TARGET=wasm32-wasi cargo test -v --all-features diff --git a/crates/main/src/module_manifest.rs b/crates/main/src/module_manifest.rs index 0f05512..3611107 100644 --- a/crates/main/src/module_manifest.rs +++ b/crates/main/src/module_manifest.rs @@ -22,25 +22,25 @@ macro_rules! module_manifest { ($authors:expr, $version:expr, $description:expr, $repository:expr) => { fluence::internal::build_timestamp!(); - const __FCE_SDK_AUTHORS_SIZE: usize = $authors.as_bytes().len(); - const __FCE_SDK_VERSION_SIZE: usize = $version.as_bytes().len(); - const __FCE_SDK_DESCRIPTION_SIZE: usize = $description.as_bytes().len(); - const __FCE_SDK_REPOSITORY_SIZE: usize = $repository.as_bytes().len(); - const __FCE_SDK_BUILD_TIME_SIZE: usize = __FCE_SDK_BUILD_TIME.as_bytes().len(); - const __FCE_SDK_FIELD_PREFIX_SIZE: usize = std::mem::size_of::(); + const __M_SDK_AUTHORS_SIZE: usize = $authors.as_bytes().len(); + const __M_SDK_VERSION_SIZE: usize = $version.as_bytes().len(); + const __M_SDK_DESCRIPTION_SIZE: usize = $description.as_bytes().len(); + const __M_SDK_REPOSITORY_SIZE: usize = $repository.as_bytes().len(); + const __M_SDK_BUILD_TIME_SIZE: usize = __M_SDK_BUILD_TIME.as_bytes().len(); + const __M_SDK_FIELD_PREFIX_SIZE: usize = std::mem::size_of::(); - const __FCE_MANIFEST_SIZE: usize = __FCE_SDK_AUTHORS_SIZE - + __FCE_SDK_VERSION_SIZE - + __FCE_SDK_DESCRIPTION_SIZE - + __FCE_SDK_REPOSITORY_SIZE - + __FCE_SDK_BUILD_TIME_SIZE - + __FCE_SDK_FIELD_PREFIX_SIZE * 5; + const __M_MANIFEST_SIZE: usize = __M_SDK_AUTHORS_SIZE + + __M_SDK_VERSION_SIZE + + __M_SDK_DESCRIPTION_SIZE + + __M_SDK_REPOSITORY_SIZE + + __M_SDK_BUILD_TIME_SIZE + + __M_SDK_FIELD_PREFIX_SIZE * 5; - const fn __fce_sdk_append_data( - mut manifest: [u8; __FCE_MANIFEST_SIZE], + const fn __m_sdk_append_data( + mut manifest: [u8; __M_MANIFEST_SIZE], data: &'static str, offset: usize, - ) -> ([u8; __FCE_MANIFEST_SIZE], usize) { + ) -> ([u8; __M_MANIFEST_SIZE], usize) { let data_as_bytes = data.as_bytes(); let data_len = data_as_bytes.len(); @@ -48,7 +48,7 @@ macro_rules! module_manifest { let data_len_u64 = data_len as u64; let data_len_le_bytes = data_len_u64.to_le_bytes(); let mut byte_idx = 0; - while byte_idx < __FCE_SDK_FIELD_PREFIX_SIZE { + while byte_idx < __M_SDK_FIELD_PREFIX_SIZE { manifest[offset + byte_idx] = data_len_le_bytes[byte_idx]; byte_idx += 1; } @@ -56,22 +56,22 @@ macro_rules! module_manifest { // write data let mut byte_idx = 0; while byte_idx < data_len { - manifest[__FCE_SDK_FIELD_PREFIX_SIZE + offset + byte_idx] = data_as_bytes[byte_idx]; + manifest[__M_SDK_FIELD_PREFIX_SIZE + offset + byte_idx] = data_as_bytes[byte_idx]; byte_idx += 1; } - (manifest, offset + __FCE_SDK_FIELD_PREFIX_SIZE + data_len) + (manifest, offset + __M_SDK_FIELD_PREFIX_SIZE + data_len) } - const fn generate_manifest() -> [u8; __FCE_MANIFEST_SIZE] { - let manifest: [u8; __FCE_MANIFEST_SIZE] = [0; __FCE_MANIFEST_SIZE]; + const fn generate_manifest() -> [u8; __M_MANIFEST_SIZE] { + let manifest: [u8; __M_MANIFEST_SIZE] = [0; __M_MANIFEST_SIZE]; let offset = 0; - let (manifest, offset) = __fce_sdk_append_data(manifest, $authors, offset); - let (manifest, offset) = __fce_sdk_append_data(manifest, $version, offset); - let (manifest, offset) = __fce_sdk_append_data(manifest, $description, offset); - let (manifest, offset) = __fce_sdk_append_data(manifest, $repository, offset); - let (manifest, _) = __fce_sdk_append_data(manifest, __FCE_SDK_BUILD_TIME, offset); + let (manifest, offset) = __m_sdk_append_data(manifest, $authors, offset); + let (manifest, offset) = __m_sdk_append_data(manifest, $version, offset); + let (manifest, offset) = __m_sdk_append_data(manifest, $description, offset); + let (manifest, offset) = __m_sdk_append_data(manifest, $repository, offset); + let (manifest, _) = __m_sdk_append_data(manifest, __M_SDK_BUILD_TIME, offset); manifest } @@ -79,7 +79,7 @@ macro_rules! module_manifest { #[cfg(target_arch = "wasm32")] #[link_section = "__fluence_wasm_module_manifest"] #[doc(hidden)] - pub static __FCE_WASM_MODULE_MANIFEST: [u8; __FCE_MANIFEST_SIZE] = generate_manifest(); + pub static __M_WASM_MODULE_MANIFEST: [u8; __M_MANIFEST_SIZE] = generate_manifest(); }; () => { diff --git a/crates/main/src/sdk_version_embedder.rs b/crates/main/src/sdk_version_embedder.rs index 57c2071..e1036be 100644 --- a/crates/main/src/sdk_version_embedder.rs +++ b/crates/main/src/sdk_version_embedder.rs @@ -38,4 +38,4 @@ pub const VERSION_SECTION_NAME: &str = "__fluence_sdk_version"; #[cfg(target_arch = "wasm32")] #[link_section = "__fluence_sdk_version"] #[doc(hidden)] -pub static __FCE_SDK_VERSION: [u8; VERSION_SIZE] = sdk_version(); +pub static __M_SDK_VERSION: [u8; VERSION_SIZE] = sdk_version(); diff --git a/crates/marine-macro-impl/src/ast_types.rs b/crates/marine-macro-impl/src/ast_types.rs index f3d39ea..9c1a119 100644 --- a/crates/marine-macro-impl/src/ast_types.rs +++ b/crates/marine-macro-impl/src/ast_types.rs @@ -81,7 +81,7 @@ pub(crate) struct AstFn { } #[derive(Clone)] -pub(crate) enum FCEAst { +pub(crate) enum MarineAst { Function(AstFn), ExternMod(AstExternMod), Record(AstRecord), diff --git a/crates/marine-macro-impl/src/lib.rs b/crates/marine-macro-impl/src/lib.rs index 5e8f4e6..be36494 100644 --- a/crates/marine-macro-impl/src/lib.rs +++ b/crates/marine-macro-impl/src/lib.rs @@ -14,7 +14,7 @@ * limitations under the License. */ -#![doc(html_root_url = "https://docs.rs/wit-support/0.5.0")] +#![doc(html_root_url = "https://docs.rs/marine-macro-impl/0.6.2")] #![deny( dead_code, nonstandard_style, @@ -32,7 +32,7 @@ mod ast_types; mod export_ast_types; -mod fce_macro_impl; +mod marine_macro_impl; mod parsed_type; mod parse_macro_input; mod token_stream_generator; @@ -40,7 +40,7 @@ mod utils; mod wasm_type; pub use export_ast_types::*; -pub use fce_macro_impl::marine; +pub use marine_macro_impl::marine; pub use parsed_type::ParsedType; pub use token_stream_generator::GENERATED_WRAPPER_FUNC_PREFIX; pub use token_stream_generator::GENERATED_SECTION_PREFIX; diff --git a/crates/marine-macro-impl/src/fce_macro_impl.rs b/crates/marine-macro-impl/src/marine_macro_impl.rs similarity index 91% rename from crates/marine-macro-impl/src/fce_macro_impl.rs rename to crates/marine-macro-impl/src/marine_macro_impl.rs index aae28ec..5c5c4b8 100644 --- a/crates/marine-macro-impl/src/fce_macro_impl.rs +++ b/crates/marine-macro-impl/src/marine_macro_impl.rs @@ -23,11 +23,11 @@ use syn::Result; pub fn marine(tokens: TokenStream) -> Result { let item = syn::parse2::(tokens)?; // convert proc_macro2 token to internal AST type - let fce_ast_item = item.parse_macro_input()?; + let marine_ast_item = item.parse_macro_input()?; // convert internal AST type to sequence of tokens let mut tokens = TokenStream::new(); - fce_ast_item.to_tokens(&mut tokens); + marine_ast_item.to_tokens(&mut tokens); Ok(tokens) } diff --git a/crates/marine-macro-impl/src/parse_macro_input.rs b/crates/marine-macro-impl/src/parse_macro_input.rs index 39668e2..f119a72 100644 --- a/crates/marine-macro-impl/src/parse_macro_input.rs +++ b/crates/marine-macro-impl/src/parse_macro_input.rs @@ -19,14 +19,14 @@ mod item_foreign_mod; mod item_record; mod utils; -use crate::ast_types::FCEAst; +use crate::ast_types::MarineAst; pub(crate) trait ParseMacroInput { - fn parse_macro_input(self) -> syn::Result; + fn parse_macro_input(self) -> syn::Result; } impl ParseMacroInput for syn::Item { - fn parse_macro_input(self) -> syn::Result { + fn parse_macro_input(self) -> syn::Result { use syn::spanned::Spanned; match self { @@ -35,7 +35,7 @@ impl ParseMacroInput for syn::Item { syn::Item::Struct(item_struct) => item_struct.parse_macro_input(), _ => Err(syn::Error::new( self.span(), - "At now, #[fce] could be applied only to a function, extern block or struct", + "At now, #[marine] could be applied only to a function, extern block or struct", )), } } diff --git a/crates/marine-macro-impl/src/parse_macro_input/item_fn.rs b/crates/marine-macro-impl/src/parse_macro_input/item_fn.rs index 14df958..33b6230 100644 --- a/crates/marine-macro-impl/src/parse_macro_input/item_fn.rs +++ b/crates/marine-macro-impl/src/parse_macro_input/item_fn.rs @@ -17,7 +17,7 @@ use super::ParseMacroInput; use crate::ast_types; use crate::ParsedType; -use crate::ast_types::FCEAst; +use crate::ast_types::MarineAst; use crate::ast_types::AstFn; use crate::ast_types::AstFnArgument; use crate::syn_error; @@ -26,7 +26,7 @@ use syn::Result; use syn::spanned::Spanned; impl ParseMacroInput for syn::ItemFn { - fn parse_macro_input(self) -> Result { + fn parse_macro_input(self) -> Result { let signature = try_to_ast_signature(self.sig.clone(), self.vis.clone())?; // this check specific only for export functions @@ -38,7 +38,7 @@ impl ParseMacroInput for syn::ItemFn { check_args(parsed_args)?; check_output_type(&signature.output_type, self.sig.output.span())?; - let ast_fn = FCEAst::Function(AstFn { + let ast_fn = MarineAst::Function(AstFn { signature, original: self, }); @@ -96,7 +96,7 @@ pub(super) fn try_to_ast_signature( Ok(ast_function_item) } -/// Check whether the #[fce] macro could be applied to a function. +/// Check whether the #[marine] macro could be applied to a function. #[rustfmt::skip] fn check_function(signature: &syn::Signature) -> Result<()> { let syn::Signature { @@ -109,19 +109,19 @@ fn check_function(signature: &syn::Signature) -> Result<()> { } = signature; if let Some(constness) = constness { - return syn_error!(constness.span, "FCE export function shouldn't be constant"); + return syn_error!(constness.span, "Marine export function shouldn't be constant"); } if let Some(unsafety) = unsafety { - return syn_error!(unsafety.span, "FCE export function shouldn't be unsafe"); + return syn_error!(unsafety.span, "Marine export function shouldn't be unsafe"); } if let Some(abi) = abi { - return syn_error!(abi.extern_token.span, "FCE export function shouldn't have any custom linkage"); + return syn_error!(abi.extern_token.span, "Marine export function shouldn't have any custom linkage"); } if generics.where_clause.is_some() { - return syn_error!(signature.span(), "FCE export function shouldn't use template parameters"); + return syn_error!(signature.span(), "Marine export function shouldn't use template parameters"); } if variadic.is_some() { - return syn_error!(variadic.span(), "FCE export function shouldn't use variadic interface"); + return syn_error!(variadic.span(), "Marine export function shouldn't use variadic interface"); } // TODO: check for a lifetime diff --git a/crates/marine-macro-impl/src/parse_macro_input/item_foreign_mod.rs b/crates/marine-macro-impl/src/parse_macro_input/item_foreign_mod.rs index 72d4f14..0947f4f 100644 --- a/crates/marine-macro-impl/src/parse_macro_input/item_foreign_mod.rs +++ b/crates/marine-macro-impl/src/parse_macro_input/item_foreign_mod.rs @@ -16,7 +16,7 @@ use super::ParseMacroInput; use crate::ast_types; -use crate::ast_types::FCEAst; +use crate::ast_types::MarineAst; use crate::syn_error; use syn::Result; @@ -27,7 +27,7 @@ const LINK_NAME_DIRECTIVE_NAME: &str = "link_name"; const WASM_IMPORT_MODULE_DIRECTIVE_NAME: &str = "wasm_import_module"; impl ParseMacroInput for syn::ItemForeignMod { - fn parse_macro_input(self) -> Result { + fn parse_macro_input(self) -> Result { check_foreign_section(&self)?; let wasm_import_module: Option = parse_wasm_import_module(&self); @@ -41,7 +41,7 @@ impl ParseMacroInput for syn::ItemForeignMod { imports, original: self, }; - Ok(FCEAst::ExternMod(extern_mod_item)) + Ok(MarineAst::ExternMod(extern_mod_item)) } } @@ -135,7 +135,7 @@ fn parse_raw_foreign_item(raw_item: syn::ForeignItem) -> Result { return syn_error!( raw_item.span(), - "#[fce] could be applied only to a function, struct ot extern block" + "#[marine] could be applied only to a function, struct ot extern block" ) } }; diff --git a/crates/marine-macro-impl/src/parse_macro_input/item_record.rs b/crates/marine-macro-impl/src/parse_macro_input/item_record.rs index 51c0ce3..656f3ee 100644 --- a/crates/marine-macro-impl/src/parse_macro_input/item_record.rs +++ b/crates/marine-macro-impl/src/parse_macro_input/item_record.rs @@ -18,7 +18,7 @@ use super::ParseMacroInput; use crate::ast_types; use crate::ast_types::AstRecordField; use crate::ast_types::AstRecordFields; -use crate::ast_types::FCEAst; +use crate::ast_types::MarineAst; use crate::syn_error; use crate::parsed_type::ParsedType; @@ -26,7 +26,7 @@ use syn::Result; use syn::spanned::Spanned; impl ParseMacroInput for syn::ItemStruct { - fn parse_macro_input(self) -> Result { + fn parse_macro_input(self) -> Result { check_record(&self)?; let fields = match &self.fields { @@ -44,7 +44,7 @@ impl ParseMacroInput for syn::ItemStruct { original: self, }; - Ok(FCEAst::Record(ast_record_item)) + Ok(MarineAst::Record(ast_record_item)) } } @@ -55,7 +55,7 @@ fn check_record(record: &syn::ItemStruct) -> Result<()> { { return syn_error!( record.span(), - "#[fce] couldn't be applied to a struct with generics or lifetimes" + "#[marine] couldn't be applied to a struct with generics or lifetimes" ); } @@ -94,7 +94,7 @@ fn check_field(field: &syn::Field) -> Result<()> { _ => { return syn_error!( field.span(), - "#[fce] could be applied only to struct with all public fields" + "#[marine] could be applied only to struct with all public fields" ) } }; diff --git a/crates/marine-macro-impl/src/parsed_type/fn_epilog.rs b/crates/marine-macro-impl/src/parsed_type/fn_epilog.rs index 9d4990d..37b7802 100644 --- a/crates/marine-macro-impl/src/parsed_type/fn_epilog.rs +++ b/crates/marine-macro-impl/src/parsed_type/fn_epilog.rs @@ -106,7 +106,7 @@ fn generate_epilog(ty: &Option) -> proc_macro2::TokenStream { None => quote!(), Some(ParsedType::Record(..)) => { quote! { - let result_ptr = result.__fce_generated_serialize(); + let result_ptr = result.__m_generated_serialize(); fluence::internal::set_result_ptr(result_ptr as _); } } @@ -117,7 +117,7 @@ fn generate_epilog(ty: &Option) -> proc_macro2::TokenStream { } } Some(ParsedType::Vector(ty, _)) => { - let generated_serializer_name = "__fce_generated_vec_serializer"; + let generated_serializer_name = "__m_generated_vec_serializer"; let generated_serializer_ident = new_ident!(generated_serializer_name); let vector_serializer = super::vector_ser_der::generate_vector_ser(ty, generated_serializer_name); diff --git a/crates/marine-macro-impl/src/parsed_type/fn_prolog.rs b/crates/marine-macro-impl/src/parsed_type/fn_prolog.rs index 498204c..e031609 100644 --- a/crates/marine-macro-impl/src/parsed_type/fn_prolog.rs +++ b/crates/marine-macro-impl/src/parsed_type/fn_prolog.rs @@ -130,7 +130,7 @@ fn generate_type_lifting_prolog( }, ParsedType::Vector(ty, _) => { let generated_der_name = - format!("__fce_generated_vec_deserializer_{}", supplied_arg_start_id); + format!("__m_generated_vec_deserializer_{}", supplied_arg_start_id); let generated_der_name = crate::utils::prepare_ident(generated_der_name); let generated_der_ident = new_ident!(generated_der_name); @@ -145,7 +145,7 @@ fn generate_type_lifting_prolog( ParsedType::Record(record_name, _) => { let record_ident = new_ident!(record_name); quote! { - let #type_modifier #converted_arg_ident = #record_ident::__fce_generated_deserialize(#ptr as _); + let #type_modifier #converted_arg_ident = #record_ident::__m_generated_deserialize(#ptr as _); } } _ => panic!( diff --git a/crates/marine-macro-impl/src/parsed_type/foreign_mod_arg.rs b/crates/marine-macro-impl/src/parsed_type/foreign_mod_arg.rs index e760445..130a71e 100644 --- a/crates/marine-macro-impl/src/parsed_type/foreign_mod_arg.rs +++ b/crates/marine-macro-impl/src/parsed_type/foreign_mod_arg.rs @@ -35,7 +35,7 @@ impl ForeignModArgGlueCodeGenerator for ParsedType { quote! { #arg.0 as _, #arg.1 as _ } } ParsedType::Record(..) => quote! { - #arg.__fce_generated_serialize() as _ + #arg.__m_generated_serialize() as _ }, ty @ ParsedType::Boolean(_) => { let deref_sign = maybe_deref(ty); diff --git a/crates/marine-macro-impl/src/parsed_type/foreign_mod_epilog.rs b/crates/marine-macro-impl/src/parsed_type/foreign_mod_epilog.rs index 6c87989..2df8e82 100644 --- a/crates/marine-macro-impl/src/parsed_type/foreign_mod_epilog.rs +++ b/crates/marine-macro-impl/src/parsed_type/foreign_mod_epilog.rs @@ -57,7 +57,7 @@ impl ForeignModEpilogGlueCodeGenerator for Option { ) }, Some(ParsedType::Vector(ty, _)) => { - let generated_der_name = "__fce_generated_vec_deserializer"; + let generated_der_name = "__m_generated_vec_deserializer"; let generated_der_ident = new_ident!(generated_der_name); let vector_deserializer = super::vector_ser_der::generate_vector_der(ty, generated_der_name); @@ -74,7 +74,7 @@ impl ForeignModEpilogGlueCodeGenerator for Option { let record_ident = new_ident!(record_name); quote! { - #record_ident::__fce_generated_deserialize(fluence::internal::get_result_ptr() as _) + #record_ident::__m_generated_deserialize(fluence::internal::get_result_ptr() as _) } } _ => panic!( diff --git a/crates/marine-macro-impl/src/parsed_type/foreign_mod_prolog.rs b/crates/marine-macro-impl/src/parsed_type/foreign_mod_prolog.rs index 8f79d12..97a2673 100644 --- a/crates/marine-macro-impl/src/parsed_type/foreign_mod_prolog.rs +++ b/crates/marine-macro-impl/src/parsed_type/foreign_mod_prolog.rs @@ -128,7 +128,7 @@ impl ForeignModPrologGlueCodeGenerator for Vec { } fn vector_arg_transforms(ty: &ParsedType, arg_name: &str) -> proc_macro2::TokenStream { - let generated_ser_name = format!("__fce_generated_vec_serializer_{}", arg_name); + let generated_ser_name = format!("__m_generated_vec_serializer_{}", arg_name); let generated_ser_name = crate::utils::prepare_ident(generated_ser_name); let generated_ser_ident = new_ident!(generated_ser_name); let arg_ident = new_ident!(arg_name); diff --git a/crates/marine-macro-impl/src/parsed_type/vector_ser_der/der.rs b/crates/marine-macro-impl/src/parsed_type/vector_ser_der/der.rs index a76e428..180e8ac 100644 --- a/crates/marine-macro-impl/src/parsed_type/vector_ser_der/der.rs +++ b/crates/marine-macro-impl/src/parsed_type/vector_ser_der/der.rs @@ -69,7 +69,7 @@ pub(super) fn record_der(record_name: &str) -> proc_macro2::TokenStream { let mut result = Vec::with_capacity(arg.len()); for offset in arg { - let value = #record_name_ident::__fce_generated_deserialize(offset as _); + let value = #record_name_ident::__m_generated_deserialize(offset as _); result.push(value); } diff --git a/crates/marine-macro-impl/src/parsed_type/vector_ser_der/ser.rs b/crates/marine-macro-impl/src/parsed_type/vector_ser_der/ser.rs index c3c1c5c..c72339e 100644 --- a/crates/marine-macro-impl/src/parsed_type/vector_ser_der/ser.rs +++ b/crates/marine-macro-impl/src/parsed_type/vector_ser_der/ser.rs @@ -65,7 +65,7 @@ pub(super) fn record_ser() -> proc_macro2::TokenStream { let mut result: Vec = Vec::with_capacity(arg.len()); for value in arg { - result.push(value.__fce_generated_serialize() as _); + result.push(value.__m_generated_serialize() as _); } let result_ptr = result.as_ptr(); diff --git a/crates/marine-macro-impl/src/token_stream_generator.rs b/crates/marine-macro-impl/src/token_stream_generator.rs index 58997d5..d73771e 100644 --- a/crates/marine-macro-impl/src/token_stream_generator.rs +++ b/crates/marine-macro-impl/src/token_stream_generator.rs @@ -18,18 +18,18 @@ mod fn_generator; mod foreign_mod_generator; mod record_generator; -use crate::ast_types::FCEAst; +use crate::ast_types::MarineAst; -pub const GENERATED_WRAPPER_FUNC_PREFIX: &str = "__fce_generated_wrapper_func_"; -pub const GENERATED_SECTION_PREFIX: &str = "__fce_generated_section__"; -pub const GENERATED_GLOBAL_PREFIX: &str = "__fce_generated_static_global_"; +pub const GENERATED_WRAPPER_FUNC_PREFIX: &str = "__m_generated_wrapper_func_"; +pub const GENERATED_SECTION_PREFIX: &str = "__m_generated_section__"; +pub const GENERATED_GLOBAL_PREFIX: &str = "__m_generated_static_global_"; -impl quote::ToTokens for FCEAst { +impl quote::ToTokens for MarineAst { fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { match self { - FCEAst::Function(ast_function) => ast_function.to_tokens(tokens), - FCEAst::ExternMod(ast_extern) => ast_extern.to_tokens(tokens), - FCEAst::Record(ast_record) => ast_record.to_tokens(tokens), + MarineAst::Function(ast_function) => ast_function.to_tokens(tokens), + MarineAst::ExternMod(ast_extern) => ast_extern.to_tokens(tokens), + MarineAst::Record(ast_record) => ast_record.to_tokens(tokens), } } } diff --git a/crates/marine-macro-impl/src/token_stream_generator/record_generator.rs b/crates/marine-macro-impl/src/token_stream_generator/record_generator.rs index be43b05..968d132 100644 --- a/crates/marine-macro-impl/src/token_stream_generator/record_generator.rs +++ b/crates/marine-macro-impl/src/token_stream_generator/record_generator.rs @@ -46,8 +46,6 @@ impl quote::ToTokens for AstRecord { let glue_code = quote::quote! { #original - // used_id_fce is a special feature that indicates that this struct will be used inside - // FCE for some internal needs #[cfg(target_arch = "wasm32")] #[doc(hidden)] #[allow(clippy::all)] @@ -77,7 +75,7 @@ fn generate_serializer_fn(record: &AstRecord) -> proc_macro2::TokenStream { }; quote::quote! { - pub fn __fce_generated_serialize(&self) -> *const u8 { + pub fn __m_generated_serialize(&self) -> *const u8 { // 4 is an average size of a possible record field let mut raw_record: Vec = Vec::with_capacity(4 * #fields_count); @@ -106,7 +104,7 @@ fn generate_deserializer_fn(record: &AstRecord) -> proc_macro2::TokenStream { let record_size = crate::utils::get_record_size(fields.iter().map(|ast_field| &ast_field.ty)); quote::quote! { - pub unsafe fn __fce_generated_deserialize(record_ptr: *const u8) -> Self { + pub unsafe fn __m_generated_deserialize(record_ptr: *const u8) -> Self { let raw_record: Vec = Vec::from_raw_parts(record_ptr as _, #record_size, #record_size); #fields_der diff --git a/crates/marine-macro-impl/src/token_stream_generator/record_generator/field_values_builder.rs b/crates/marine-macro-impl/src/token_stream_generator/record_generator/field_values_builder.rs index f6de5af..ffef1b7 100644 --- a/crates/marine-macro-impl/src/token_stream_generator/record_generator/field_values_builder.rs +++ b/crates/marine-macro-impl/src/token_stream_generator/record_generator/field_values_builder.rs @@ -263,7 +263,7 @@ impl FieldValuesBuilder { } fn vector_der(&mut self, ty: &ParsedType, field: &syn::Ident) -> TokenStream { - let generated_der_name = format!("__fce_generated_vec_deserializer_{}", self.value_id); + let generated_der_name = format!("__m_generated_vec_deserializer_{}", self.value_id); let generated_der_name = crate::utils::prepare_ident(generated_der_name); let generated_der_ident = new_ident!(generated_der_name); @@ -308,7 +308,7 @@ impl FieldValuesBuilder { raw_record[#value_id + 3], ]); - let #field = #record_ident::__fce_generated_deserialize(offset as _); + let #field = #record_ident::__m_generated_deserialize(offset as _); }; self.value_id += std::mem::size_of::(); diff --git a/crates/marine-macro-impl/src/token_stream_generator/record_generator/record_serializer.rs b/crates/marine-macro-impl/src/token_stream_generator/record_generator/record_serializer.rs index f3de573..144a883 100644 --- a/crates/marine-macro-impl/src/token_stream_generator/record_generator/record_serializer.rs +++ b/crates/marine-macro-impl/src/token_stream_generator/record_generator/record_serializer.rs @@ -52,7 +52,7 @@ impl RecordSerGlueCodeGenerator for AstRecord { } ParsedType::Vector(ty, _) => { let generated_ser_name = format!( - "__fce_generated_vec_serializer_{}_{}", + "__m_generated_vec_serializer_{}_{}", field.name.as_ref().unwrap(), id ); @@ -72,7 +72,7 @@ impl RecordSerGlueCodeGenerator for AstRecord { } ParsedType::Record(..) => { quote! { - let serialized_struct_ptr = #field_ident.__fce_generated_serialize() as usize; + let serialized_struct_ptr = #field_ident.__m_generated_serialize() as usize; raw_record.extend(&serialized_struct_ptr.to_le_bytes()); } } diff --git a/crates/marine-macro-impl/src/utils.rs b/crates/marine-macro-impl/src/utils.rs index 76007a4..ebfb86f 100644 --- a/crates/marine-macro-impl/src/utils.rs +++ b/crates/marine-macro-impl/src/utils.rs @@ -24,10 +24,10 @@ macro_rules! new_ident { #[macro_export] macro_rules! prepare_global_data { - ($fce_type: ident, $self: ident, $name: expr, $data: ident, $data_size: ident, $global_static_name: ident, $section_name: ident) => { + ($mtype: ident, $self: ident, $name: expr, $data: ident, $data_size: ident, $global_static_name: ident, $section_name: ident) => { // TODO: change serialization protocol - let fce_type = crate::export_ast_types::SDKAst::$fce_type($self.clone().into()); - let $data = serde_json::to_vec(&fce_type).unwrap(); + let mtype = crate::export_ast_types::SDKAst::$mtype($self.clone().into()); + let $data = serde_json::to_vec(&mtype).unwrap(); let $data_size = $data.len(); let $data = syn::LitByteStr::new(&$data, proc_macro2::Span::call_site()); diff --git a/crates/marine-macro-impl/tests/generation_tests/exports/arrays/expanded.rs b/crates/marine-macro-impl/tests/generation_tests/exports/arrays/expanded.rs index eb45c58..e12e5b6 100644 --- a/crates/marine-macro-impl/tests/generation_tests/exports/arrays/expanded.rs +++ b/crates/marine-macro-impl/tests/generation_tests/exports/arrays/expanded.rs @@ -6,17 +6,17 @@ pub fn inner_arrays_1(arg: Vec>>>) -> Vec>>> { #[no_mangle] #[doc(hidden)] #[allow(clippy::all)] -pub unsafe fn __fce_generated_wrapper_func_inner_arrays_1(arg_0: u32, arg_1: u32) { - unsafe fn __fce_generated_vec_deserializer_0(offset: u32, size: u32) -> Vec>>> { - unsafe fn __fce_generated_vec_deserializer_0_Vec_Vec_u8__( +pub unsafe fn __m_generated_wrapper_func_inner_arrays_1(arg_0: u32, arg_1: u32) { + unsafe fn __m_generated_vec_deserializer_0(offset: u32, size: u32) -> Vec>>> { + unsafe fn __m_generated_vec_deserializer_0_Vec_Vec_u8__( offset: u32, size: u32 ) -> Vec>> { - unsafe fn __fce_generated_vec_deserializer_0_Vec_Vec_u8___Vec_u8_( + unsafe fn __m_generated_vec_deserializer_0_Vec_Vec_u8___Vec_u8_( offset: u32, size: u32 ) -> Vec> { - unsafe fn __fce_generated_vec_deserializer_0_Vec_Vec_u8___Vec_u8__u8( + unsafe fn __m_generated_vec_deserializer_0_Vec_Vec_u8___Vec_u8__u8( offset: u32, size: u32 ) -> Vec { @@ -29,7 +29,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_1(arg_0: u32, arg_1: u32 let mut arg = arg.into_iter(); while let Some(offset) = arg.next() { let size = arg.next().unwrap(); - let value = __fce_generated_vec_deserializer_0_Vec_Vec_u8___Vec_u8__u8( + let value = __m_generated_vec_deserializer_0_Vec_Vec_u8___Vec_u8__u8( offset as _, size as _ ); @@ -45,7 +45,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_1(arg_0: u32, arg_1: u32 while let Some(offset) = arg.next() { let size = arg.next().unwrap(); let value = - __fce_generated_vec_deserializer_0_Vec_Vec_u8___Vec_u8_(offset as _, size as _); + __m_generated_vec_deserializer_0_Vec_Vec_u8___Vec_u8_(offset as _, size as _); result.push(value); } result @@ -56,21 +56,21 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_1(arg_0: u32, arg_1: u32 let mut arg = arg.into_iter(); while let Some(offset) = arg.next() { let size = arg.next().unwrap(); - let value = __fce_generated_vec_deserializer_0_Vec_Vec_u8__(offset as _, size as _); + let value = __m_generated_vec_deserializer_0_Vec_Vec_u8__(offset as _, size as _); result.push(value); } result } - let converted_arg_0 = __fce_generated_vec_deserializer_0(arg_0 as _, arg_1 as _); + let converted_arg_0 = __m_generated_vec_deserializer_0(arg_0 as _, arg_1 as _); let result = inner_arrays_1(converted_arg_0); - unsafe fn __fce_generated_vec_serializer(arg: &Vec>>>) -> (u32, u32) { - unsafe fn __fce_generated_vec_serializer_Vec_Vec_u8__( + unsafe fn __m_generated_vec_serializer(arg: &Vec>>>) -> (u32, u32) { + unsafe fn __m_generated_vec_serializer_Vec_Vec_u8__( arg: &Vec>> ) -> (u32, u32) { - unsafe fn __fce_generated_vec_serializer_Vec_Vec_u8___Vec_u8_( + unsafe fn __m_generated_vec_serializer_Vec_Vec_u8___Vec_u8_( arg: &Vec> ) -> (u32, u32) { - unsafe fn __fce_generated_vec_serializer_Vec_Vec_u8___Vec_u8__u8( + unsafe fn __m_generated_vec_serializer_Vec_Vec_u8___Vec_u8__u8( arg: &Vec ) -> (u32, u32) { (arg.as_ptr() as _, arg.len() as _) @@ -78,7 +78,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_1(arg_0: u32, arg_1: u32 let mut result: Vec = Vec::with_capacity(2 * arg.len()); for value in arg { let (ptr, size) = - __fce_generated_vec_serializer_Vec_Vec_u8___Vec_u8__u8(&value); + __m_generated_vec_serializer_Vec_Vec_u8___Vec_u8__u8(&value); result.push(ptr as _); result.push(size as _); } @@ -89,7 +89,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_1(arg_0: u32, arg_1: u32 } let mut result: Vec = Vec::with_capacity(2 * arg.len()); for value in arg { - let (ptr, size) = __fce_generated_vec_serializer_Vec_Vec_u8___Vec_u8_(&value); + let (ptr, size) = __m_generated_vec_serializer_Vec_Vec_u8___Vec_u8_(&value); result.push(ptr as _); result.push(size as _); } @@ -100,7 +100,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_1(arg_0: u32, arg_1: u32 } let mut result: Vec = Vec::with_capacity(2 * arg.len()); for value in arg { - let (ptr, size) = __fce_generated_vec_serializer_Vec_Vec_u8__(&value); + let (ptr, size) = __m_generated_vec_serializer_Vec_Vec_u8__(&value); result.push(ptr as _); result.push(size as _); } @@ -110,7 +110,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_1(arg_0: u32, arg_1: u32 (result_ptr as _, result_len as _) } { - let (serialized_vec_ptr, serialized_vec_size) = __fce_generated_vec_serializer(&result); + let (serialized_vec_ptr, serialized_vec_size) = __m_generated_vec_serializer(&result); fluence::internal::set_result_ptr(serialized_vec_ptr as _); fluence::internal::set_result_size(serialized_vec_size as _); } @@ -119,7 +119,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_1(arg_0: u32, arg_1: u32 #[cfg(target_arch = "wasm32")] #[doc(hidden)] #[allow(clippy::all)] -#[link_section = "__fce_generated_section__inner_arrays_1"] -pub static __fce_generated_static_global_inner_arrays_1: [u8; 330usize] = { +#[link_section = "__m_generated_section__inner_arrays_1"] +pub static __m_generated_static_global_inner_arrays_1: [u8; 330usize] = { * b"{\"ast_type\":\"Function\",\"signature\":{\"name\":\"inner_arrays_1\",\"arguments\":[{\"name\":\"arg\",\"ty\":{\"Vector\":[{\"Vector\":[{\"Vector\":[{\"Vector\":[{\"U8\":\"ByValue\"},\"ByValue\"]},\"ByValue\"]},\"ByValue\"]},\"ByValue\"]}}],\"output_types\":[{\"Vector\":[{\"Vector\":[{\"Vector\":[{\"Vector\":[{\"U8\":\"ByValue\"},\"ByValue\"]},\"ByValue\"]},\"ByValue\"]},\"ByValue\"]}]}}" }; diff --git a/crates/marine-macro-impl/tests/generation_tests/exports/arrays/fce.rs b/crates/marine-macro-impl/tests/generation_tests/exports/arrays/marine.rs similarity index 100% rename from crates/marine-macro-impl/tests/generation_tests/exports/arrays/fce.rs rename to crates/marine-macro-impl/tests/generation_tests/exports/arrays/marine.rs diff --git a/crates/marine-macro-impl/tests/generation_tests/exports/basic_types/expanded.rs b/crates/marine-macro-impl/tests/generation_tests/exports/basic_types/expanded.rs index eaf6e34..0d5b20b 100644 --- a/crates/marine-macro-impl/tests/generation_tests/exports/basic_types/expanded.rs +++ b/crates/marine-macro-impl/tests/generation_tests/exports/basic_types/expanded.rs @@ -19,7 +19,7 @@ pub fn all_types( #[no_mangle] #[doc(hidden)] #[allow(clippy::all)] -pub unsafe fn __fce_generated_wrapper_func_all_types( +pub unsafe fn __m_generated_wrapper_func_all_types( arg_0: i8, arg_1: i16, arg_2: i32, @@ -46,10 +46,10 @@ pub unsafe fn __fce_generated_wrapper_func_all_types( let converted_arg_8 = arg_8 as _; let converted_arg_9 = arg_9 as _; let converted_arg_10 = String::from_raw_parts(arg_10 as _, arg_11 as _, arg_11 as _); - unsafe fn __fce_generated_vec_deserializer_12(offset: u32, size: u32) -> Vec { + unsafe fn __m_generated_vec_deserializer_12(offset: u32, size: u32) -> Vec { Vec::from_raw_parts(offset as _, size as _, size as _) } - let converted_arg_12 = __fce_generated_vec_deserializer_12(arg_12 as _, arg_13 as _); + let converted_arg_12 = __m_generated_vec_deserializer_12(arg_12 as _, arg_13 as _); let result = all_types( converted_arg_0, converted_arg_1, @@ -64,11 +64,11 @@ pub unsafe fn __fce_generated_wrapper_func_all_types( converted_arg_10, converted_arg_12 ); - unsafe fn __fce_generated_vec_serializer(arg: &Vec) -> (u32, u32) { + unsafe fn __m_generated_vec_serializer(arg: &Vec) -> (u32, u32) { (arg.as_ptr() as _, arg.len() as _) } { - let (serialized_vec_ptr, serialized_vec_size) = __fce_generated_vec_serializer(&result); + let (serialized_vec_ptr, serialized_vec_size) = __m_generated_vec_serializer(&result); fluence::internal::set_result_ptr(serialized_vec_ptr as _); fluence::internal::set_result_size(serialized_vec_size as _); } @@ -77,7 +77,7 @@ pub unsafe fn __fce_generated_wrapper_func_all_types( #[cfg(target_arch = "wasm32")] #[doc(hidden)] #[allow(clippy::all)] -#[link_section = "__fce_generated_section__all_types"] -pub static __fce_generated_static_global_all_types: [u8; 636usize] = { +#[link_section = "__m_generated_section__all_types"] +pub static __m_generated_static_global_all_types: [u8; 636usize] = { * b"{\"ast_type\":\"Function\",\"signature\":{\"name\":\"all_types\",\"arguments\":[{\"name\":\"arg_0\",\"ty\":{\"I8\":\"ByValue\"}},{\"name\":\"arg_1\",\"ty\":{\"I16\":\"ByValue\"}},{\"name\":\"arg_2\",\"ty\":{\"I32\":\"ByValue\"}},{\"name\":\"arg_3\",\"ty\":{\"I64\":\"ByValue\"}},{\"name\":\"arg_4\",\"ty\":{\"U8\":\"ByValue\"}},{\"name\":\"arg_5\",\"ty\":{\"U16\":\"ByValue\"}},{\"name\":\"arg_6\",\"ty\":{\"U32\":\"ByValue\"}},{\"name\":\"arg_7\",\"ty\":{\"U64\":\"ByValue\"}},{\"name\":\"arg_8\",\"ty\":{\"F32\":\"ByValue\"}},{\"name\":\"arg_9\",\"ty\":{\"F64\":\"ByValue\"}},{\"name\":\"arg_10\",\"ty\":{\"Utf8String\":\"ByValue\"}},{\"name\":\"arg_11\",\"ty\":{\"Vector\":[{\"U8\":\"ByValue\"},\"ByValue\"]}}],\"output_types\":[{\"Vector\":[{\"U8\":\"ByValue\"},\"ByValue\"]}]}}" }; diff --git a/crates/marine-macro-impl/tests/generation_tests/exports/basic_types/fce.rs b/crates/marine-macro-impl/tests/generation_tests/exports/basic_types/marine.rs similarity index 100% rename from crates/marine-macro-impl/tests/generation_tests/exports/basic_types/fce.rs rename to crates/marine-macro-impl/tests/generation_tests/exports/basic_types/marine.rs diff --git a/crates/marine-macro-impl/tests/generation_tests/exports/refs/expanded.rs b/crates/marine-macro-impl/tests/generation_tests/exports/refs/expanded.rs index 518552a..bf46929 100644 --- a/crates/marine-macro-impl/tests/generation_tests/exports/refs/expanded.rs +++ b/crates/marine-macro-impl/tests/generation_tests/exports/refs/expanded.rs @@ -6,9 +6,9 @@ pub fn test_array_refs(arg: &Vec>) -> &Vec>>> { #[no_mangle] #[doc(hidden)] #[allow(clippy::all)] -pub unsafe fn __fce_generated_wrapper_func_test_array_refs(arg_0: u32, arg_1: u32) { - unsafe fn __fce_generated_vec_deserializer_0(offset: u32, size: u32) -> Vec> { - unsafe fn __fce_generated_vec_deserializer_0_String(offset: u32, size: u32) -> Vec { +pub unsafe fn __m_generated_wrapper_func_test_array_refs(arg_0: u32, arg_1: u32) { + unsafe fn __m_generated_vec_deserializer_0(offset: u32, size: u32) -> Vec> { + unsafe fn __m_generated_vec_deserializer_0_String(offset: u32, size: u32) -> Vec { let vec_passing_size = 2; let mut arg: Vec = Vec::from_raw_parts(offset as _, (vec_passing_size * size) as _, (vec_passing_size * size) as _); @@ -27,21 +27,21 @@ pub unsafe fn __fce_generated_wrapper_func_test_array_refs(arg_0: u32, arg_1: u3 let mut arg = arg.into_iter(); while let Some(offset) = arg.next() { let size = arg.next().unwrap(); - let value = __fce_generated_vec_deserializer_0_String(offset as _, size as _); + let value = __m_generated_vec_deserializer_0_String(offset as _, size as _); result.push(value); } result } - let converted_arg_0 = __fce_generated_vec_deserializer_0(arg_0 as _, arg_1 as _); + let converted_arg_0 = __m_generated_vec_deserializer_0(arg_0 as _, arg_1 as _); let result = test_array_refs(&converted_arg_0); - unsafe fn __fce_generated_vec_serializer(arg: &Vec>>>) -> (u32, u32) { - unsafe fn __fce_generated_vec_serializer_Vec_Vec_String__( + unsafe fn __m_generated_vec_serializer(arg: &Vec>>>) -> (u32, u32) { + unsafe fn __m_generated_vec_serializer_Vec_Vec_String__( arg: &Vec>> ) -> (u32, u32) { - unsafe fn __fce_generated_vec_serializer_Vec_Vec_String___Vec_String_( + unsafe fn __m_generated_vec_serializer_Vec_Vec_String___Vec_String_( arg: &Vec> ) -> (u32, u32) { - unsafe fn __fce_generated_vec_serializer_Vec_Vec_String___Vec_String__String( + unsafe fn __m_generated_vec_serializer_Vec_Vec_String___Vec_String__String( arg: &Vec ) -> (u32, u32) { let mut result: Vec = Vec::with_capacity(arg.len()); @@ -57,7 +57,7 @@ pub unsafe fn __fce_generated_wrapper_func_test_array_refs(arg_0: u32, arg_1: u3 let mut result: Vec = Vec::with_capacity(2 * arg.len()); for value in arg { let (ptr, size) = - __fce_generated_vec_serializer_Vec_Vec_String___Vec_String__String(&value); + __m_generated_vec_serializer_Vec_Vec_String___Vec_String__String(&value); result.push(ptr as _); result.push(size as _); } @@ -69,7 +69,7 @@ pub unsafe fn __fce_generated_wrapper_func_test_array_refs(arg_0: u32, arg_1: u3 let mut result: Vec = Vec::with_capacity(2 * arg.len()); for value in arg { let (ptr, size) = - __fce_generated_vec_serializer_Vec_Vec_String___Vec_String_(&value); + __m_generated_vec_serializer_Vec_Vec_String___Vec_String_(&value); result.push(ptr as _); result.push(size as _); } @@ -80,7 +80,7 @@ pub unsafe fn __fce_generated_wrapper_func_test_array_refs(arg_0: u32, arg_1: u3 } let mut result: Vec = Vec::with_capacity(2 * arg.len()); for value in arg { - let (ptr, size) = __fce_generated_vec_serializer_Vec_Vec_String__(&value); + let (ptr, size) = __m_generated_vec_serializer_Vec_Vec_String__(&value); result.push(ptr as _); result.push(size as _); } @@ -90,7 +90,7 @@ pub unsafe fn __fce_generated_wrapper_func_test_array_refs(arg_0: u32, arg_1: u3 (result_ptr as _, result_len as _) } { - let (serialized_vec_ptr, serialized_vec_size) = __fce_generated_vec_serializer(&result); + let (serialized_vec_ptr, serialized_vec_size) = __m_generated_vec_serializer(&result); fluence::internal::set_result_ptr(serialized_vec_ptr as _); fluence::internal::set_result_size(serialized_vec_size as _); } @@ -99,7 +99,7 @@ pub unsafe fn __fce_generated_wrapper_func_test_array_refs(arg_0: u32, arg_1: u3 #[cfg(target_arch = "wasm32")] #[doc(hidden)] #[allow(clippy::all)] -#[link_section = "__fce_generated_section__test_array_refs"] -pub static __fce_generated_static_global_test_array_refs: [u8; 297usize] = { +#[link_section = "__m_generated_section__test_array_refs"] +pub static __m_generated_static_global_test_array_refs: [u8; 297usize] = { * b"{\"ast_type\":\"Function\",\"signature\":{\"name\":\"test_array_refs\",\"arguments\":[{\"name\":\"arg\",\"ty\":{\"Vector\":[{\"Vector\":[{\"Utf8String\":\"ByValue\"},\"ByValue\"]},\"ByRef\"]}}],\"output_types\":[{\"Vector\":[{\"Vector\":[{\"Vector\":[{\"Vector\":[{\"Utf8String\":\"ByValue\"},\"ByValue\"]},\"ByValue\"]},\"ByValue\"]},\"ByRef\"]}]}}" }; diff --git a/crates/marine-macro-impl/tests/generation_tests/exports/refs/fce.rs b/crates/marine-macro-impl/tests/generation_tests/exports/refs/marine.rs similarity index 100% rename from crates/marine-macro-impl/tests/generation_tests/exports/refs/fce.rs rename to crates/marine-macro-impl/tests/generation_tests/exports/refs/marine.rs diff --git a/crates/marine-macro-impl/tests/generation_tests/records/call_parameters/expanded.rs b/crates/marine-macro-impl/tests/generation_tests/records/call_parameters/expanded.rs index 4c01651..27cdfa7 100644 --- a/crates/marine-macro-impl/tests/generation_tests/records/call_parameters/expanded.rs +++ b/crates/marine-macro-impl/tests/generation_tests/records/call_parameters/expanded.rs @@ -16,7 +16,7 @@ pub struct CallParameters { #[doc(hidden)] #[allow(clippy::all)] impl CallParameters { - pub fn __fce_generated_serialize(&self) -> *const u8 { + pub fn __m_generated_serialize(&self) -> *const u8 { let mut raw_record: Vec = Vec::with_capacity(4 * 6usize); let field_ident_ptr = self.init_peer_id.as_ptr() as u32; raw_record.extend(&field_ident_ptr.to_le_bytes()); @@ -33,15 +33,15 @@ impl CallParameters { let field_ident_ptr = self.particle_id.as_ptr() as u32; raw_record.extend(&field_ident_ptr.to_le_bytes()); raw_record.extend(&(self.particle_id.len() as u32).to_le_bytes()); - unsafe fn __fce_generated_vec_serializer_tetraplets_5( + unsafe fn __m_generated_vec_serializer_tetraplets_5( arg: &Vec> ) -> (u32, u32) { - unsafe fn __fce_generated_vec_serializer_tetraplets_5_SecurityTetraplet( + unsafe fn __m_generated_vec_serializer_tetraplets_5_SecurityTetraplet( arg: &Vec ) -> (u32, u32) { let mut result: Vec = Vec::with_capacity(arg.len()); for value in arg { - result.push(value.__fce_generated_serialize() as _); + result.push(value.__m_generated_serialize() as _); } let result_ptr = result.as_ptr(); let result_len = result.len(); @@ -51,7 +51,7 @@ impl CallParameters { let mut result: Vec = Vec::with_capacity(2 * arg.len()); for value in arg { let (ptr, size) = - __fce_generated_vec_serializer_tetraplets_5_SecurityTetraplet(&value); + __m_generated_vec_serializer_tetraplets_5_SecurityTetraplet(&value); result.push(ptr as _); result.push(size as _); } @@ -61,14 +61,14 @@ impl CallParameters { (result_ptr as _, result_len as _) } let serialized_arg_5 = - unsafe { __fce_generated_vec_serializer_tetraplets_5(&self.tetraplets) }; + unsafe { __m_generated_vec_serializer_tetraplets_5(&self.tetraplets) }; raw_record.extend(&serialized_arg_5.0.to_le_bytes()); raw_record.extend(&serialized_arg_5.1.to_le_bytes()); let raw_record_ptr = raw_record.as_ptr(); fluence::internal::add_object_to_release(Box::new(raw_record)); raw_record_ptr as _ } - pub unsafe fn __fce_generated_deserialize(record_ptr: *const u8) -> Self { + pub unsafe fn __m_generated_deserialize(record_ptr: *const u8) -> Self { let raw_record: Vec = Vec::from_raw_parts(record_ptr as _, 48usize, 48usize); let field_0 = unsafe { let offset = u32::from_le_bytes([ @@ -145,18 +145,18 @@ impl CallParameters { ]); String::from_raw_parts(offset as _, size as _, size as _) }; - unsafe fn __fce_generated_vec_deserializer_40( + unsafe fn __m_generated_vec_deserializer_40( offset: u32, size: u32 ) -> Vec> { - unsafe fn __fce_generated_vec_deserializer_40_SecurityTetraplet( + unsafe fn __m_generated_vec_deserializer_40_SecurityTetraplet( offset: u32, size: u32 ) -> Vec { let mut arg: Vec = Vec::from_raw_parts(offset as _, size as _, size as _); let mut result = Vec::with_capacity(arg.len()); for offset in arg { - let value = SecurityTetraplet::__fce_generated_deserialize(offset as _); + let value = SecurityTetraplet::__m_generated_deserialize(offset as _); result.push(value); } result @@ -168,7 +168,7 @@ impl CallParameters { let mut arg = arg.into_iter(); while let Some(offset) = arg.next() { let size = arg.next().unwrap(); - let value = __fce_generated_vec_deserializer_40_SecurityTetraplet( + let value = __m_generated_vec_deserializer_40_SecurityTetraplet( offset as _, size as _ ); @@ -188,7 +188,7 @@ impl CallParameters { raw_record[40usize + 6], raw_record[40usize + 7], ]); - let field_5 = unsafe { __fce_generated_vec_deserializer_40(offset as _, size as _) }; + let field_5 = unsafe { __m_generated_vec_deserializer_40(offset as _, size as _) }; Self { init_peer_id: field_0, service_id: field_1, @@ -202,7 +202,7 @@ impl CallParameters { #[cfg(target_arch = "wasm32")] #[doc(hidden)] #[allow(clippy::all)] -#[link_section = "__fce_generated_section__CallParameters"] -pub static __fce_generated_static_global_CallParameters: [u8; 455usize] = { +#[link_section = "__m_generated_section__CallParameters"] +pub static __m_generated_static_global_CallParameters: [u8; 455usize] = { * b"{\"ast_type\":\"Record\",\"name\":\"CallParameters\",\"fields\":{\"Named\":[{\"name\":\"init_peer_id\",\"ty\":{\"Utf8String\":\"ByValue\"}},{\"name\":\"service_id\",\"ty\":{\"Utf8String\":\"ByValue\"}},{\"name\":\"service_creator_peer_id\",\"ty\":{\"Utf8String\":\"ByValue\"}},{\"name\":\"host_id\",\"ty\":{\"Utf8String\":\"ByValue\"}},{\"name\":\"particle_id\",\"ty\":{\"Utf8String\":\"ByValue\"}},{\"name\":\"tetraplets\",\"ty\":{\"Vector\":[{\"Vector\":[{\"Record\":[\"SecurityTetraplet\",\"ByValue\"]},\"ByValue\"]},\"ByValue\"]}}]}}" }; diff --git a/crates/marine-macro-impl/tests/generation_tests/records/call_parameters/fce.rs b/crates/marine-macro-impl/tests/generation_tests/records/call_parameters/marine.rs similarity index 100% rename from crates/marine-macro-impl/tests/generation_tests/records/call_parameters/fce.rs rename to crates/marine-macro-impl/tests/generation_tests/records/call_parameters/marine.rs diff --git a/crates/marine-macro-impl/tests/generation_tests/records/use_as_type/expanded.rs b/crates/marine-macro-impl/tests/generation_tests/records/use_as_type/expanded.rs index 79ae75d..706d4f6 100644 --- a/crates/marine-macro-impl/tests/generation_tests/records/use_as_type/expanded.rs +++ b/crates/marine-macro-impl/tests/generation_tests/records/use_as_type/expanded.rs @@ -6,27 +6,27 @@ pub fn inner_arrays_2(arg: Vec>>>) -> Vec Vec>>> { - unsafe fn __fce_generated_vec_deserializer_0_Vec_Vec_TestRecord__( + unsafe fn __m_generated_vec_deserializer_0_Vec_Vec_TestRecord__( offset: u32, size: u32 ) -> Vec>> { - unsafe fn __fce_generated_vec_deserializer_0_Vec_Vec_TestRecord___Vec_TestRecord_( + unsafe fn __m_generated_vec_deserializer_0_Vec_Vec_TestRecord___Vec_TestRecord_( offset: u32, size: u32 ) -> Vec> { - unsafe fn __fce_generated_vec_deserializer_0_Vec_Vec_TestRecord___Vec_TestRecord__TestRecord( + unsafe fn __m_generated_vec_deserializer_0_Vec_Vec_TestRecord___Vec_TestRecord__TestRecord( offset: u32, size: u32 ) -> Vec { let mut arg: Vec = Vec::from_raw_parts(offset as _, size as _, size as _); let mut result = Vec::with_capacity(arg.len()); for offset in arg { - let value = TestRecord::__fce_generated_deserialize(offset as _); + let value = TestRecord::__m_generated_deserialize(offset as _); result.push(value); } result @@ -38,7 +38,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_2(arg_0: u32, arg_1: u32 let mut arg = arg.into_iter(); while let Some(offset) = arg.next() { let size = arg.next().unwrap(); - let value = __fce_generated_vec_deserializer_0_Vec_Vec_TestRecord___Vec_TestRecord__TestRecord ( offset as _ , size as _ ) ; + let value = __m_generated_vec_deserializer_0_Vec_Vec_TestRecord___Vec_TestRecord__TestRecord ( offset as _ , size as _ ) ; result.push(value); } result @@ -50,7 +50,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_2(arg_0: u32, arg_1: u32 let mut arg = arg.into_iter(); while let Some(offset) = arg.next() { let size = arg.next().unwrap(); - let value = __fce_generated_vec_deserializer_0_Vec_Vec_TestRecord___Vec_TestRecord_( + let value = __m_generated_vec_deserializer_0_Vec_Vec_TestRecord___Vec_TestRecord_( offset as _, size as _ ); @@ -65,26 +65,26 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_2(arg_0: u32, arg_1: u32 while let Some(offset) = arg.next() { let size = arg.next().unwrap(); let value = - __fce_generated_vec_deserializer_0_Vec_Vec_TestRecord__(offset as _, size as _); + __m_generated_vec_deserializer_0_Vec_Vec_TestRecord__(offset as _, size as _); result.push(value); } result } - let converted_arg_0 = __fce_generated_vec_deserializer_0(arg_0 as _, arg_1 as _); + let converted_arg_0 = __m_generated_vec_deserializer_0(arg_0 as _, arg_1 as _); let result = inner_arrays_2(converted_arg_0); - unsafe fn __fce_generated_vec_serializer(arg: &Vec>>>) -> (u32, u32) { - unsafe fn __fce_generated_vec_serializer_Vec_Vec_TestRecord__( + unsafe fn __m_generated_vec_serializer(arg: &Vec>>>) -> (u32, u32) { + unsafe fn __m_generated_vec_serializer_Vec_Vec_TestRecord__( arg: &Vec>> ) -> (u32, u32) { - unsafe fn __fce_generated_vec_serializer_Vec_Vec_TestRecord___Vec_TestRecord_( + unsafe fn __m_generated_vec_serializer_Vec_Vec_TestRecord___Vec_TestRecord_( arg: &Vec> ) -> (u32, u32) { - unsafe fn __fce_generated_vec_serializer_Vec_Vec_TestRecord___Vec_TestRecord__TestRecord( + unsafe fn __m_generated_vec_serializer_Vec_Vec_TestRecord___Vec_TestRecord__TestRecord( arg: &Vec ) -> (u32, u32) { let mut result: Vec = Vec::with_capacity(arg.len()); for value in arg { - result.push(value.__fce_generated_serialize() as _); + result.push(value.__m_generated_serialize() as _); } let result_ptr = result.as_ptr(); let result_len = result.len(); @@ -93,7 +93,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_2(arg_0: u32, arg_1: u32 } let mut result: Vec = Vec::with_capacity(2 * arg.len()); for value in arg { - let ( ptr , size ) = __fce_generated_vec_serializer_Vec_Vec_TestRecord___Vec_TestRecord__TestRecord ( & value ) ; + let ( ptr , size ) = __m_generated_vec_serializer_Vec_Vec_TestRecord___Vec_TestRecord__TestRecord ( & value ) ; result.push(ptr as _); result.push(size as _); } @@ -105,7 +105,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_2(arg_0: u32, arg_1: u32 let mut result: Vec = Vec::with_capacity(2 * arg.len()); for value in arg { let (ptr, size) = - __fce_generated_vec_serializer_Vec_Vec_TestRecord___Vec_TestRecord_(&value); + __m_generated_vec_serializer_Vec_Vec_TestRecord___Vec_TestRecord_(&value); result.push(ptr as _); result.push(size as _); } @@ -116,7 +116,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_2(arg_0: u32, arg_1: u32 } let mut result: Vec = Vec::with_capacity(2 * arg.len()); for value in arg { - let (ptr, size) = __fce_generated_vec_serializer_Vec_Vec_TestRecord__(&value); + let (ptr, size) = __m_generated_vec_serializer_Vec_Vec_TestRecord__(&value); result.push(ptr as _); result.push(size as _); } @@ -126,7 +126,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_2(arg_0: u32, arg_1: u32 (result_ptr as _, result_len as _) } { - let (serialized_vec_ptr, serialized_vec_size) = __fce_generated_vec_serializer(&result); + let (serialized_vec_ptr, serialized_vec_size) = __m_generated_vec_serializer(&result); fluence::internal::set_result_ptr(serialized_vec_ptr as _); fluence::internal::set_result_size(serialized_vec_size as _); } @@ -135,7 +135,7 @@ pub unsafe fn __fce_generated_wrapper_func_inner_arrays_2(arg_0: u32, arg_1: u32 #[cfg(target_arch = "wasm32")] #[doc(hidden)] #[allow(clippy::all)] -#[link_section = "__fce_generated_section__inner_arrays_2"] -pub static __fce_generated_static_global_inner_arrays_2: [u8; 368usize] = { +#[link_section = "__m_generated_section__inner_arrays_2"] +pub static __m_generated_static_global_inner_arrays_2: [u8; 368usize] = { * b"{\"ast_type\":\"Function\",\"signature\":{\"name\":\"inner_arrays_2\",\"arguments\":[{\"name\":\"arg\",\"ty\":{\"Vector\":[{\"Vector\":[{\"Vector\":[{\"Vector\":[{\"Record\":[\"TestRecord\",\"ByValue\"]},\"ByValue\"]},\"ByValue\"]},\"ByValue\"]},\"ByValue\"]}}],\"output_types\":[{\"Vector\":[{\"Vector\":[{\"Vector\":[{\"Vector\":[{\"Record\":[\"TestRecord\",\"ByValue\"]},\"ByValue\"]},\"ByValue\"]},\"ByValue\"]},\"ByValue\"]}]}}" }; \ No newline at end of file diff --git a/crates/marine-macro-impl/tests/generation_tests/records/use_as_type/fce.rs b/crates/marine-macro-impl/tests/generation_tests/records/use_as_type/marine.rs similarity index 100% rename from crates/marine-macro-impl/tests/generation_tests/records/use_as_type/fce.rs rename to crates/marine-macro-impl/tests/generation_tests/records/use_as_type/marine.rs diff --git a/crates/marine-macro-impl/tests/generation_tests_runner.rs b/crates/marine-macro-impl/tests/generation_tests_runner.rs index 0b112a9..8533ba3 100644 --- a/crates/marine-macro-impl/tests/generation_tests_runner.rs +++ b/crates/marine-macro-impl/tests/generation_tests_runner.rs @@ -1,43 +1,43 @@ mod utils; -use utils::test_fce_token_streams; +use utils::test_marine_token_streams; #[test] fn exports_arrays() { - assert!(test_fce_token_streams( - "tests/generation_tests/exports/arrays/fce.rs", + assert!(test_marine_token_streams( + "tests/generation_tests/exports/arrays/marine.rs", "tests/generation_tests/exports/arrays/expanded.rs", )); } #[test] fn exports_basic_types() { - assert!(test_fce_token_streams( - "tests/generation_tests/exports/basic_types/fce.rs", + assert!(test_marine_token_streams( + "tests/generation_tests/exports/basic_types/marine.rs", "tests/generation_tests/exports/basic_types/expanded.rs", )); } #[test] fn exports_refs() { - assert!(test_fce_token_streams( - "tests/generation_tests/exports/refs/fce.rs", + assert!(test_marine_token_streams( + "tests/generation_tests/exports/refs/marine.rs", "tests/generation_tests/exports/refs/expanded.rs", )); } #[test] fn records_call_parameters() { - assert!(test_fce_token_streams( - "tests/generation_tests/records/call_parameters/fce.rs", + assert!(test_marine_token_streams( + "tests/generation_tests/records/call_parameters/marine.rs", "tests/generation_tests/records/call_parameters/expanded.rs", )); } #[test] fn records_use_as_type() { - assert!(test_fce_token_streams( - "tests/generation_tests/records/use_as_type/fce.rs", + assert!(test_marine_token_streams( + "tests/generation_tests/records/use_as_type/marine.rs", "tests/generation_tests/records/use_as_type/expanded.rs", )); } diff --git a/crates/marine-macro-impl/tests/utils.rs b/crates/marine-macro-impl/tests/utils.rs index 0e8241a..ecac466 100644 --- a/crates/marine-macro-impl/tests/utils.rs +++ b/crates/marine-macro-impl/tests/utils.rs @@ -21,22 +21,22 @@ use pretty_assertions::assert_eq; use std::io::Read; use std::path::Path; -pub fn test_fce_token_streams(fce_path: FP, expanded_path: EP) -> bool +pub fn test_marine_token_streams(marine_path: FP, expanded_path: EP) -> bool where FP: AsRef, EP: AsRef, { - let fce_item = stream_from_file(fce_path); - let test_token_stream = quote::quote! { #fce_item }; - let fce_token_streams = marine(test_token_stream) - .unwrap_or_else(|e| panic!("failed to apply the fce macro due {}", e)); + let marine_item = stream_from_file(marine_path); + let test_token_stream = quote::quote! { #marine_item }; + let marine_token_streams = marine(test_token_stream) + .unwrap_or_else(|e| panic!("failed to apply the marine macro due {}", e)); let expanded_item = items_from_file(expanded_path); - let fce_item = to_syn_item(fce_token_streams); + let marine_item = to_syn_item(marine_token_streams); - assert_eq!(expanded_item, fce_item); + assert_eq!(expanded_item, marine_item); - fce_item == expanded_item + marine_item == expanded_item } fn stream_from_file

(path: P) -> proc_macro2::TokenStream diff --git a/crates/marine-macro/src/lib.rs b/crates/marine-macro/src/lib.rs index e53954c..d0d1dad 100644 --- a/crates/marine-macro/src/lib.rs +++ b/crates/marine-macro/src/lib.rs @@ -14,17 +14,17 @@ * limitations under the License. */ -//! Defines the #[fce] macro that should be used with all export functions, extern blocks. +//! Defines the #[marine] macro that should be used with all export functions, extern blocks. //! At now, It supports the following types that could be used as parameters in export or foreign //! functions: i8, i16, i32, i64, u8, u16, u32, u64, f32, f64, bool, String, Vec. Also struct //! where all fields are public and have aforementioned types could be used as parameters. In this -//! case #[fce] should be also applied to this structs. +//! case #[marine] should be also applied to this structs. //! //! # Examples //! //! This example shows how a function could be exported: //! ```ignore -//! #[fce] +//! #[marine] //! pub fn greeting(name: String) -> String { //! format!("Hi {}", name) //! } @@ -36,13 +36,13 @@ //! ```ignore //! use fluence::MountedBinaryResult; //! -//! #[fce] +//! #[marine] //! pub fn read_ipfs_file(file_path: String) -> MountedBinaryResult { //! let hash = calculate_hash(file_path); //! ipfs(vec![hash]) //! } //! -//! #[fce] +//! #[marine] //! #[link(wasm_import_module = "ipfs_node")] //! extern "C" { //! pub fn ipfs(file_hash: Vec) -> MountedBinaryResult; @@ -83,7 +83,7 @@ pub fn marine(_attr: TokenStream, input: TokenStream) -> TokenStream { note = "please use the #[marine] macro instead" )] #[proc_macro_attribute] -pub fn fce(_attr: TokenStream, input: TokenStream) -> TokenStream { +pub fn marine(_attr: TokenStream, input: TokenStream) -> TokenStream { // into converts proc_macro::TokenStream to proc_macro2::TokenStream match marine_impl(input.into()) { Ok(v) => v, diff --git a/crates/marine-test-macro-impl/Cargo.toml b/crates/marine-test-macro-impl/Cargo.toml index 8ab2ebd..944bb48 100644 --- a/crates/marine-test-macro-impl/Cargo.toml +++ b/crates/marine-test-macro-impl/Cargo.toml @@ -13,8 +13,8 @@ license = "Apache-2.0" all-features = true [dependencies] -#fluence-app-service = { version = "0.7.0", features = ["raw-module-api"] } -fce-wit-parser = "0.5.0" +fluence-app-service = { version = "0.7.0", features = ["raw-module-api"] } +marine-it-parser = "0.5.0" darling = "0.12.2" quote = "1.0.9" diff --git a/crates/marine-test-macro-impl/src/attributes.rs b/crates/marine-test-macro-impl/src/attributes.rs index bd5e482..e999473 100644 --- a/crates/marine-test-macro-impl/src/attributes.rs +++ b/crates/marine-test-macro-impl/src/attributes.rs @@ -16,9 +16,9 @@ use darling::FromMeta; -/// Describes attributes of `fce_test` macro. +/// Describes attributes of `marine_test` macro. #[derive(Debug, Default, Clone, FromMeta)] -pub(crate) struct FCETestAttributes { +pub(crate) struct MTestAttributes { /// Path to a config file of a tested service. pub(crate) config_path: String, diff --git a/crates/marine-test-macro-impl/src/errors.rs b/crates/marine-test-macro-impl/src/errors.rs index 05bb4fc..e2e4309 100644 --- a/crates/marine-test-macro-impl/src/errors.rs +++ b/crates/marine-test-macro-impl/src/errors.rs @@ -14,7 +14,7 @@ * limitations under the License. */ -use fce_wit_parser::WITParserError; +use marine_it_parser::WITParserError; use fluence_app_service::AppServiceError; use darling::Error as DarlingError; @@ -25,7 +25,7 @@ use std::path::PathBuf; #[derive(Debug, ThisError)] pub enum TestGeneratorError { - #[error("Can't load Wasm modules into FCE: {0}")] + #[error("Can't load Wasm modules into Marine: {0}")] WITParserError(#[from] WITParserError), #[error("{0}")] diff --git a/crates/marine-test-macro-impl/src/lib.rs b/crates/marine-test-macro-impl/src/lib.rs index 432d957..ae3d902 100644 --- a/crates/marine-test-macro-impl/src/lib.rs +++ b/crates/marine-test-macro-impl/src/lib.rs @@ -28,9 +28,9 @@ mod attributes; mod errors; -mod fce_test; +mod marine_test; -pub use fce_test::fce_test_impl; +pub use marine_test::marine_test_impl; pub use errors::TestGeneratorError; pub(crate) type TResult = std::result::Result; diff --git a/crates/marine-test-macro-impl/src/fce_test/config_utils.rs b/crates/marine-test-macro-impl/src/marine_test/config_utils.rs similarity index 96% rename from crates/marine-test-macro-impl/src/fce_test/config_utils.rs rename to crates/marine-test-macro-impl/src/marine_test/config_utils.rs index 22f462e..2ffb8c1 100644 --- a/crates/marine-test-macro-impl/src/fce_test/config_utils.rs +++ b/crates/marine-test-macro-impl/src/marine_test/config_utils.rs @@ -17,8 +17,8 @@ use crate::TResult; use fluence_app_service::TomlAppServiceConfig; -use fce_wit_parser::module_raw_interface; -use fce_wit_parser::interface::FCEModuleInterface; +use marine_it_parser::module_raw_interface; +use marine_it_parser::interface::FCEModuleInterface; use std::path::PathBuf; diff --git a/crates/marine-test-macro-impl/src/fce_test/glue_code_generator.rs b/crates/marine-test-macro-impl/src/marine_test/glue_code_generator.rs similarity index 74% rename from crates/marine-test-macro-impl/src/fce_test/glue_code_generator.rs rename to crates/marine-test-macro-impl/src/marine_test/glue_code_generator.rs index ce0949c..ab58fd0 100644 --- a/crates/marine-test-macro-impl/src/fce_test/glue_code_generator.rs +++ b/crates/marine-test-macro-impl/src/marine_test/glue_code_generator.rs @@ -14,11 +14,11 @@ * limitations under the License. */ -use crate::attributes::FCETestAttributes; +use crate::attributes::MTestAttributes; use crate::TResult; use crate::TestGeneratorError; -use crate::fce_test; -use crate::fce_test::config_utils; +use crate::marine_test; +use crate::marine_test::config_utils; use fluence_app_service::TomlAppServiceConfig; use proc_macro2::TokenStream; @@ -30,7 +30,7 @@ use std::path::PathBuf; /// Generates glue code for tests. /// F.e. for this test for the greeting service ///```ignore -/// #[fce_test( +/// #[marine_test( /// config_path = "/path/to/service/config/Config.toml", /// modules_dir = "/path/to/modules/dir" /// )] @@ -43,25 +43,25 @@ use std::path::PathBuf; /// the following glue code would be generated: ///```ignore /// // (0) -/// pub mod __fce_generated_greeting { -/// struct FCEGeneratedStructgreeting { -/// fce: std::rc::Rc>, +/// pub mod __m_generated_greeting { +/// struct MGeneratedStructgreeting { +/// marine: std::rc::Rc>, /// } /// -/// impl FCEGeneratedStructgreeting { -/// pub fn new(fce: std::rc::Rc>) -> Self { -/// Self { fce } +/// impl MGeneratedStructgreeting { +/// pub fn new(marine: std::rc::Rc>) -> Self { +/// Self { marine } /// } /// /// pub fn greeting(&mut self, name: String) -> String { /// use std::ops::DerefMut; /// let arguments = fluence_test::internal::serde_json::json!([name]); /// let result = self -/// .fce +/// .marine /// .as_ref /// .borrow_mut() /// .call_with_module_name("greeting", "greeting", arguments, <_>::default()) -/// .expect("call to FCE failed"); +/// .expect("call to Marine failed"); /// let result: String = fluence_test::internal::serde_json::from_value(result) /// .expect("the default deserializer shouldn't fail"); /// result @@ -76,7 +76,7 @@ use std::path::PathBuf; /// let tmp_dir = tmp_dir.to_string_lossy().to_string(); /// std::fs::create_dir(&tmp_dir).expect("can't create a directory for service in tmp"); /// -/// let mut __fce_generated_fce_config = fluence_test::internal::TomlAppServiceConfig::load("/path/to/greeting/Config.toml".to_string()) +/// let mut __m_generated_marine_config = fluence_test::internal::TomlAppServiceConfig::load("/path/to/greeting/Config.toml".to_string()) /// .unwrap_or_else(|e| { /// panic!( /// "app service located at `{}` config can't be loaded: {}", @@ -84,19 +84,19 @@ use std::path::PathBuf; /// ) /// }); /// -/// __fce_generated_fce_config.service_base_dir = Some("/path/to/tmp".to_string()); +/// __m_generated_marine_config.service_base_dir = Some("/path/to/tmp".to_string()); /// -/// let fce = fluence_test::internal::AppService::new_with_empty_facade( -/// __fce_generated_fce_config, +/// let marine = fluence_test::internal::AppService::new_with_empty_facade( +/// __m_generated_marine_config, /// "3640e972-92e3-47cb-b95f-4e3c5bcf0f14", /// std::collections::HashMap::new(), /// ).unwrap_or_else(|e| panic!("app service can't be created: {}", e)); /// -/// let fce = std::rc::Rc::new(std::cell::RefCell::new(fce)); +/// let marine = std::rc::Rc::new(std::cell::RefCell::new(marine)); /// /// // (2) /// -/// let mut greeting = __fce_generated_greeting::FCEGeneratedStructgreeting::new(fce); +/// let mut greeting = __m_generated_greeting::MGeneratedStructgreeting::new(marine); /// /// // (3) /// @@ -113,23 +113,23 @@ use std::path::PathBuf; /// [(3), (4)] - original_block pub(super) fn generate_test_glue_code( func_item: syn::ItemFn, - attrs: FCETestAttributes, + attrs: MTestAttributes, file_path: PathBuf, ) -> TResult { let config_path = file_path.join(&attrs.config_path); - let fce_config = TomlAppServiceConfig::load(&config_path)?; - let modules_dir = match config_utils::resolve_modules_dir(&fce_config, attrs.modules_dir) { + let marine_config = TomlAppServiceConfig::load(&config_path)?; + let modules_dir = match config_utils::resolve_modules_dir(&marine_config, attrs.modules_dir) { Some(modules_dir) => modules_dir, None => return Err(TestGeneratorError::ModulesDirUnspecified), }; let app_service_ctor = generate_app_service_ctor(&attrs.config_path, &modules_dir)?; let modules_dir = file_path.join(modules_dir); - let module_interfaces = fce_test::config_utils::collect_modules(&fce_config, modules_dir)?; + let module_interfaces = marine_test::config_utils::collect_modules(&marine_config, modules_dir)?; let module_definitions = - fce_test::module_generator::generate_module_definitions(module_interfaces.iter())?; + marine_test::module_generator::generate_module_definitions(module_interfaces.iter())?; let module_iter = module_interfaces.iter().map(|module| module.name); let module_ctors = generate_module_ctors(module_iter)?; @@ -143,7 +143,7 @@ pub(super) fn generate_test_glue_code( // definitions for wasm modules specified in config #(#module_definitions)* - // AppService constructor and instantiation to implicit `fce` variable + // AppService constructor and instantiation to implicit `marine` variable #app_service_ctor // constructors of all modules of the tested service @@ -203,15 +203,15 @@ fn generate_app_service_ctor(config_path: &str, modules_dir: &Path) -> TResult( .map(|name| -> TResult<_> { // TODO: optimize these two call because they are called twice for each module name // and internally allocate memory in format call. - let module_name = fce_test::utils::generate_module_name(&name)?; - let struct_name = fce_test::utils::generate_struct_name(&name)?; - let name_for_user = fce_test::utils::new_ident(&name)?; + let module_name = marine_test::utils::generate_module_name(&name)?; + let struct_name = marine_test::utils::generate_struct_name(&name)?; + let name_for_user = marine_test::utils::new_ident(&name)?; let module_ctor = - quote! { let mut #name_for_user = #module_name::#struct_name::new(fce.clone()); }; + quote! { let mut #name_for_user = #module_name::#struct_name::new(marine.clone()); }; Ok(module_ctor) }) diff --git a/crates/marine-test-macro-impl/src/fce_test/fce_test_impl.rs b/crates/marine-test-macro-impl/src/marine_test/marine_test_impl.rs similarity index 86% rename from crates/marine-test-macro-impl/src/fce_test/fce_test_impl.rs rename to crates/marine-test-macro-impl/src/marine_test/marine_test_impl.rs index fbca688..832fc5a 100644 --- a/crates/marine-test-macro-impl/src/fce_test/fce_test_impl.rs +++ b/crates/marine-test-macro-impl/src/marine_test/marine_test_impl.rs @@ -14,16 +14,16 @@ * limitations under the License. */ -use crate::attributes::FCETestAttributes; +use crate::attributes::MTestAttributes; use crate::TResult; -use crate::fce_test::glue_code_generator::generate_test_glue_code; +use crate::marine_test::glue_code_generator::generate_test_glue_code; use proc_macro2::TokenStream; use darling::FromMeta; use syn::parse::Parser; use std::path::PathBuf; -pub fn fce_test_impl( +pub fn marine_test_impl( attrs: TokenStream, input: TokenStream, file_path: PathBuf, @@ -32,7 +32,7 @@ pub fn fce_test_impl( let parser = syn::punctuated::Punctuated::::parse_terminated; let attrs = parser.parse2(attrs)?; let attrs: Vec = attrs.into_iter().collect(); - let attrs = FCETestAttributes::from_list(&attrs)?; + let attrs = MTestAttributes::from_list(&attrs)?; let func_item = syn::parse2::(input)?; diff --git a/crates/marine-test-macro-impl/src/fce_test/mod.rs b/crates/marine-test-macro-impl/src/marine_test/mod.rs similarity index 91% rename from crates/marine-test-macro-impl/src/fce_test/mod.rs rename to crates/marine-test-macro-impl/src/marine_test/mod.rs index 492c7af..ffb4434 100644 --- a/crates/marine-test-macro-impl/src/fce_test/mod.rs +++ b/crates/marine-test-macro-impl/src/marine_test/mod.rs @@ -15,9 +15,9 @@ */ mod config_utils; -mod fce_test_impl; +mod marine_test_impl; mod glue_code_generator; mod module_generator; mod utils; -pub use fce_test_impl::fce_test_impl; +pub use marine_test_impl::marine_test_impl; diff --git a/crates/marine-test-macro-impl/src/fce_test/module_generator.rs b/crates/marine-test-macro-impl/src/marine_test/module_generator.rs similarity index 78% rename from crates/marine-test-macro-impl/src/fce_test/module_generator.rs rename to crates/marine-test-macro-impl/src/marine_test/module_generator.rs index 904c1c5..972cd2f 100644 --- a/crates/marine-test-macro-impl/src/fce_test/module_generator.rs +++ b/crates/marine-test-macro-impl/src/marine_test/module_generator.rs @@ -18,8 +18,8 @@ mod methods_generator; mod methods_generator_utils; mod record_type_generator; -use crate::fce_test::utils; -use crate::fce_test::config_utils::Module; +use crate::marine_test::utils; +use crate::marine_test::config_utils::Module; use crate::TResult; use proc_macro2::TokenStream; @@ -28,25 +28,25 @@ use quote::quote; /// Generates definitions of modules and records of this modules. /// F.e. for the greeting service the following definitions would be generated: ///```ignore -/// pub mod __fce_generated_greeting { -/// struct FCEGeneratedStructgreeting { -/// fce: std::rc::Rc>, +/// pub mod __m_generated_greeting { +/// struct MGeneratedStructgreeting { +/// marine: std::rc::Rc>, /// } /// -/// impl FCEGeneratedStructgreeting { -/// pub fn new(fce: std::rc::Rc>) -> Self { -/// Self { fce } +/// impl MGeneratedStructgreeting { +/// pub fn new(marine: std::rc::Rc>) -> Self { +/// Self { marine } /// } /// /// pub fn greeting(&mut self, name: String) -> String { /// use std::ops::DerefMut; /// let arguments = fluence_test::internal::serde_json::json!([name]); /// let result = self -/// .fce +/// .marine /// .as_ref /// .borrow_mut() /// .call_with_module_name("greeting", "greeting", arguments, <_>::default()) -/// .expect("call to FCE failed"); +/// .expect("call to Marine failed"); /// let result: String = fluence_test::internal::serde_json::from_value(result) /// .expect("the default deserializer shouldn't fail"); /// result @@ -81,12 +81,12 @@ fn generate_module_definition(module: &Module<'_>) -> TResult { #(#module_records)* pub struct #struct_name_ident { - fce: std::rc::Rc>, + marine: std::rc::Rc>, } impl #struct_name_ident { - pub fn new(fce: std::rc::Rc>) -> Self { - Self { fce } + pub fn new(marine: std::rc::Rc>) -> Self { + Self { marine } } } diff --git a/crates/marine-test-macro-impl/src/fce_test/module_generator/methods_generator.rs b/crates/marine-test-macro-impl/src/marine_test/module_generator/methods_generator.rs similarity index 85% rename from crates/marine-test-macro-impl/src/fce_test/module_generator/methods_generator.rs rename to crates/marine-test-macro-impl/src/marine_test/module_generator/methods_generator.rs index 61e4c3a..9799025 100644 --- a/crates/marine-test-macro-impl/src/fce_test/module_generator/methods_generator.rs +++ b/crates/marine-test-macro-impl/src/marine_test/module_generator/methods_generator.rs @@ -17,13 +17,13 @@ use super::methods_generator_utils::*; use crate::TResult; -use fce_wit_parser::interface::FCERecordTypes; -use fce_wit_parser::interface::FCEFunctionSignature; +use marine_it_parser::interface::MRecordTypes; +use marine_it_parser::interface::MFunctionSignature; pub(super) fn generate_module_methods<'m, 'r>( module_name: &str, - mut method_signatures: impl ExactSizeIterator, - records: &'r FCERecordTypes, + mut method_signatures: impl ExactSizeIterator, + records: &'r MRecordTypes, ) -> TResult> { use CallParametersSettings::*; diff --git a/crates/marine-test-macro-impl/src/fce_test/module_generator/methods_generator_utils.rs b/crates/marine-test-macro-impl/src/marine_test/module_generator/methods_generator_utils.rs similarity index 86% rename from crates/marine-test-macro-impl/src/fce_test/module_generator/methods_generator_utils.rs rename to crates/marine-test-macro-impl/src/marine_test/module_generator/methods_generator_utils.rs index 90a9e14..258c8df 100644 --- a/crates/marine-test-macro-impl/src/fce_test/module_generator/methods_generator_utils.rs +++ b/crates/marine-test-macro-impl/src/marine_test/module_generator/methods_generator_utils.rs @@ -14,14 +14,14 @@ * limitations under the License. */ -use crate::fce_test::utils::new_ident; -use crate::fce_test::utils::itype_to_tokens; +use crate::marine_test::utils::new_ident; +use crate::marine_test::utils::itype_to_tokens; use crate::TResult; -use fce_wit_parser::interface::it::IType; -use fce_wit_parser::interface::it::IFunctionArg; -use fce_wit_parser::interface::FCERecordTypes; -use fce_wit_parser::interface::FCEFunctionSignature; +use marine_it_parser::interface::it::IType; +use marine_it_parser::interface::it::IFunctionArg; +use marine_it_parser::interface::MRecordTypes; +use marine_it_parser::interface::MFunctionSignature; use proc_macro2::TokenStream; use quote::quote; @@ -34,13 +34,13 @@ pub(super) enum CallParametersSettings { pub(super) fn generate_module_method( module_name: &str, - signature: &FCEFunctionSignature, + signature: &MFunctionSignature, cp_setting: CallParametersSettings, - records: &FCERecordTypes, + records: &MRecordTypes, ) -> TResult { let arguments = generate_arguments(signature.arguments.iter(), records)?; let output_type = generate_output_type(&signature.outputs, records)?; - let fce_call = generate_fce_call(module_name, cp_setting, &signature, records)?; + let mcall = generate_marine_call(module_name, cp_setting, &signature, records)?; let (cp, func_name) = match cp_setting { CallParametersSettings::Default => { @@ -63,18 +63,18 @@ pub(super) fn generate_module_method( let module_method = quote! { pub fn #func_name(&mut self, #(#arguments),* #cp) #output_type { - #fce_call + #mcall } }; Ok(module_method) } -fn generate_fce_call( +fn generate_marine_call( module_name: &str, cp_settings: CallParametersSettings, - method_signature: &FCEFunctionSignature, - records: &FCERecordTypes, + method_signature: &MFunctionSignature, + records: &MRecordTypes, ) -> TResult { let args = method_signature.arguments.iter().map(|a| a.name.as_str()); let convert_arguments = generate_arguments_converter(args)?; @@ -122,7 +122,7 @@ fn generate_function_call( CallParametersSettings::UserDefined => quote! { cp }, }; - quote! { self.fce.as_ref().borrow_mut().call_module(#module_name, #method_name, arguments, #cp).expect("call to Marine failed"); } + quote! { self.marine.as_ref().borrow_mut().call_module(#module_name, #method_name, arguments, #cp).expect("call to Marine failed"); } } fn generate_set_result(output_type: &Option<&IType>) -> TokenStream { @@ -134,7 +134,7 @@ fn generate_set_result(output_type: &Option<&IType>) -> TokenStream { fn generate_convert_to_output( output_type: &Option<&IType>, - records: &FCERecordTypes, + records: &MRecordTypes, ) -> TResult { let result_stream = match output_type { Some(ty) => { @@ -158,7 +158,7 @@ fn generate_ret(output_type: &Option<&IType>) -> TokenStream { fn generate_arguments<'a, 'r>( arguments: impl ExactSizeIterator, - records: &'r FCERecordTypes, + records: &'r MRecordTypes, ) -> TResult> { arguments .map(|argument| -> TResult<_> { @@ -171,7 +171,7 @@ fn generate_arguments<'a, 'r>( .collect::>>() } -fn generate_output_type(output_types: &[IType], records: &FCERecordTypes) -> TResult { +fn generate_output_type(output_types: &[IType], records: &MRecordTypes) -> TResult { let output_type = get_output_type(output_types)?; match output_type { None => Ok(TokenStream::new()), diff --git a/crates/marine-test-macro-impl/src/fce_test/module_generator/record_type_generator.rs b/crates/marine-test-macro-impl/src/marine_test/module_generator/record_type_generator.rs similarity index 87% rename from crates/marine-test-macro-impl/src/fce_test/module_generator/record_type_generator.rs rename to crates/marine-test-macro-impl/src/marine_test/module_generator/record_type_generator.rs index 0a97f4f..b79a2b0 100644 --- a/crates/marine-test-macro-impl/src/fce_test/module_generator/record_type_generator.rs +++ b/crates/marine-test-macro-impl/src/marine_test/module_generator/record_type_generator.rs @@ -14,16 +14,16 @@ * limitations under the License. */ -use crate::fce_test::utils; +use crate::marine_test::utils; use crate::TResult; -use fce_wit_parser::interface::it::IRecordFieldType; -use fce_wit_parser::interface::FCERecordTypes; +use marine_it_parser::interface::it::IRecordFieldType; +use marine_it_parser::interface::MRecordTypes; use proc_macro2::TokenStream; use quote::quote; -pub(super) fn generate_records(records: &FCERecordTypes) -> TResult> { +pub(super) fn generate_records(records: &MRecordTypes) -> TResult> { use std::ops::Deref; records.iter().map(|(_, record)| -> TResult<_> { @@ -45,7 +45,7 @@ pub(super) fn generate_records(records: &FCERecordTypes) -> TResult( fields: impl ExactSizeIterator, - records: &FCERecordTypes, + records: &MRecordTypes, ) -> TResult> { fields .map(|field| -> TResult<_> { diff --git a/crates/marine-test-macro-impl/src/fce_test/utils.rs b/crates/marine-test-macro-impl/src/marine_test/utils.rs similarity index 87% rename from crates/marine-test-macro-impl/src/fce_test/utils.rs rename to crates/marine-test-macro-impl/src/marine_test/utils.rs index 21cd5a2..f814fc4 100644 --- a/crates/marine-test-macro-impl/src/fce_test/utils.rs +++ b/crates/marine-test-macro-impl/src/marine_test/utils.rs @@ -15,14 +15,14 @@ */ use crate::TResult; -use fce_wit_parser::interface::FCERecordTypes; -use fce_wit_parser::interface::it::IType; +use marine_it_parser::interface::MRecordTypes; +use marine_it_parser::interface::it::IType; use proc_macro2::TokenStream; use quote::quote; pub(super) fn generate_module_name(module_name: &str) -> TResult { - let extended_module_name = format!("__fce_generated_{}", module_name); + let extended_module_name = format!("__m_generated_{}", module_name); new_ident(&extended_module_name) } @@ -32,7 +32,7 @@ pub(super) fn generate_record_name(record_name: &str) -> TResult { } pub(super) fn generate_struct_name(struct_name: &str) -> TResult { - let extended_struct_name = format!("FCEGeneratedStruct{}", struct_name); + let extended_struct_name = format!("MGeneratedStruct{}", struct_name); new_ident(&extended_struct_name) } @@ -41,7 +41,7 @@ pub(super) fn new_ident(ident_str: &str) -> TResult { syn::parse_str::(&ident_str).map_err(Into::into) } -pub(super) fn itype_to_tokens(itype: &IType, records: &FCERecordTypes) -> TResult { +pub(super) fn itype_to_tokens(itype: &IType, records: &MRecordTypes) -> TResult { let token_stream = match itype { IType::Record(record_id) => { let record = records diff --git a/crates/marine-test-macro/src/lib.rs b/crates/marine-test-macro/src/lib.rs index 90aa8e0..ac9a789 100644 --- a/crates/marine-test-macro/src/lib.rs +++ b/crates/marine-test-macro/src/lib.rs @@ -28,14 +28,14 @@ #![warn(rust_2018_idioms)] #![recursion_limit = "1024"] -use fluence_sdk_test_macro_impl::fce_test_impl; +use marine_test_macro_impl::marine_test_impl; use proc_macro::TokenStream; use proc_macro_error::proc_macro_error; use syn::spanned::Spanned; /// This macro allows user to write tests for services in the following form: ///```rust -/// #[fce_test(config = "/path/to/Config.toml", modules_dir = "path/to/service/modules")] +/// #[marine_test(config = "/path/to/Config.toml", modules_dir = "path/to/service/modules")] /// fn test() { /// let service_result = greeting.greeting("John".to_string()); /// assert_eq!(&service_result, "Hi, name!"); @@ -43,14 +43,14 @@ use syn::spanned::Spanned; ///``` #[proc_macro_error] #[proc_macro_attribute] -pub fn fce_test(attrs: TokenStream, input: TokenStream) -> TokenStream { +pub fn marine_test(attrs: TokenStream, input: TokenStream) -> TokenStream { let attrs: proc_macro2::TokenStream = attrs.into(); let attrs_span = attrs.span(); // here it obtains a path to the current file where macro is applied let mut file_path = proc_macro::Span::call_site().source_file().path(); let _ = file_path.pop(); - match fce_test_impl(attrs, input.into(), file_path) { + match marine_test_impl(attrs, input.into(), file_path) { Ok(stream) => stream.into(), Err(e) => proc_macro_error::abort!(attrs_span, format!("{}", e)), } diff --git a/crates/timestamp-macro/src/lib.rs b/crates/timestamp-macro/src/lib.rs index 4b2740f..3769336 100644 --- a/crates/timestamp-macro/src/lib.rs +++ b/crates/timestamp-macro/src/lib.rs @@ -33,6 +33,6 @@ pub fn build_timestamp(_: TokenStream) -> TokenStream { let current_utc_date = chrono::Utc::now(); let current_utc_date = current_utc_date.to_rfc3339(); - let glue_code = quote::quote! { const __FCE_SDK_BUILD_TIME: &str = #current_utc_date; }; + let glue_code = quote::quote! { const __M_SDK_BUILD_TIME: &str = #current_utc_date; }; glue_code.into() } diff --git a/fluence-test/Cargo.toml b/fluence-test/Cargo.toml index ce10a69..0ced91f 100644 --- a/fluence-test/Cargo.toml +++ b/fluence-test/Cargo.toml @@ -20,7 +20,7 @@ doctest = false [dependencies] marine-test-macro = { path = "../crates/marine-test-macro", version = "0.1.5" } -#fluence-app-service = { version = "0.7.0", features = ["raw-module-api"] } +fluence-app-service = { version = "0.7.0", features = ["raw-module-api"] } serde = { version = "1.0.118", features = ["derive"] } serde_json = "1.0.64" diff --git a/fluence-test/src/lib.rs b/fluence-test/src/lib.rs index e5b2a9b..c35db7e 100644 --- a/fluence-test/src/lib.rs +++ b/fluence-test/src/lib.rs @@ -14,7 +14,7 @@ * limitations under the License. */ -#![doc(html_root_url = "https://docs.rs/fluence-test/0.5.0")] +#![doc(html_root_url = "https://docs.rs/fluence-test/0.1.5")] #![deny( dead_code, nonstandard_style, @@ -26,7 +26,7 @@ )] #![warn(rust_2018_idioms)] -pub use fluence_sdk_test_macro::fce_test; +pub use marine_test_macro::marine_test; pub use fluence_app_service::CallParameters; pub use fluence_app_service::SecurityTetraplet; diff --git a/fluence/src/call_parameters.rs b/fluence/src/call_parameters.rs index c5f3e88..d33dac1 100644 --- a/fluence/src/call_parameters.rs +++ b/fluence/src/call_parameters.rs @@ -60,7 +60,7 @@ pub fn get_call_parameters() -> CallParameters { unsafe { get_call_raw_parameters(); let raw_call_parameters = crate::internal::get_result_ptr(); - CallParameters::__fce_generated_deserialize(raw_call_parameters as _) + CallParameters::__m_generated_deserialize(raw_call_parameters as _) } } diff --git a/fluence/src/lib.rs b/fluence/src/lib.rs index 1678d58..b95ca5e 100644 --- a/fluence/src/lib.rs +++ b/fluence/src/lib.rs @@ -15,28 +15,28 @@ */ //! Rust backend SDK for applications on the Fluence network. This crate defines the procedure macro -//! `#[fce]` that could be applied to a function, structure or extern block. +//! `#[marine]` that could be applied to a function, structure or extern block. //! -//! Structures with `#[fce]` (hereinafter they'll be called records) could be used then in function +//! Structures with `#[marine]` (hereinafter they'll be called records) could be used then in function //! arguments and values. All fields of a record should be public and have one of the //! following primitive Rust types //! (`bool, u8, u16, u32, u64, i8, i16, i32, i64, f32, f64, String, Vec`). //! ```rust -//! use fluence::fce; +//! use fluence::marine; //! -//! #[fce] +//! #[marine] //! struct T { //! pub field_1: i32, //! pub field_2: Vec, //! } //! ``` //! -//! Functions with `#[fce]` will be exported from this module: +//! Functions with `#[marine]` will be exported from this module: //! //! ```rust -//! use fluence::fce; +//! use fluence::marine; //! -//! #[fce] +//! #[marine] //! pub fn get(url: String) { //! // ... //! } @@ -46,9 +46,9 @@ //! //! Finally, to import other wasm modules to your project use similar code: //! ```rust -//! use fluence::fce; +//! use fluence::marine; //! -//! #[fce] +//! #[marine] //! #[link(wasm_import_module = "wasm_curl.wasm")] //! extern "C" { //! #[link_name = "get"] @@ -75,7 +75,7 @@ mod mounted_binary; extern crate self as fluence; pub use marine_macro::marine; -pub use marine_macro::fce; +pub use marine_macro::marine; pub use call_parameters::CallParameters; pub use call_parameters::SecurityTetraplet; diff --git a/fluence/tests/compilation_tests/export_functions/array_inner_refs.rs b/fluence/tests/compilation_tests/export_functions/array_inner_refs.rs index d854fa8..ffbcc30 100644 --- a/fluence/tests/compilation_tests/export_functions/array_inner_refs.rs +++ b/fluence/tests/compilation_tests/export_functions/array_inner_refs.rs @@ -1,35 +1,35 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; pub fn main() {} -#[fce] +#[marine] pub fn byte_type(_arg: Vec) -> Vec { unimplemented!() } -#[fce] +#[marine] pub fn inner_arrays_1(_arg: Vec<&Vec>>>) -> Vec>>> { unimplemented!() } -#[fce] +#[marine] pub fn inner_arrays_2(_arg: Vec>>>) -> Vec>>> { unimplemented!() } -#[fce] +#[marine] pub fn inner_arrays_3(_arg: Vec>>>) -> Vec>>> { unimplemented!() } -#[fce] +#[marine] pub fn inner_arrays_4(_arg: Vec>>>) -> Vec>>> { unimplemented!() } -#[fce] +#[marine] pub fn inner_arrays_5(_arg1: i32, _arg2: Vec>>>, _arg3: i32) -> Vec>>> { unimplemented!() } diff --git a/fluence/tests/compilation_tests/export_functions/arrays.rs b/fluence/tests/compilation_tests/export_functions/arrays.rs index a5262fa..1b30588 100644 --- a/fluence/tests/compilation_tests/export_functions/arrays.rs +++ b/fluence/tests/compilation_tests/export_functions/arrays.rs @@ -1,72 +1,72 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; pub fn main() {} -#[fce] +#[marine] pub fn byte_type(_arg: Vec) -> Vec { unimplemented!() } -#[fce] +#[marine] pub fn inner_arrays_1(_arg: Vec>>>) -> Vec>>> { unimplemented!() } -#[fce] +#[marine] #[derive(Default)] pub struct TestRecord { pub field_0: i32, pub field_1: Vec>, } -#[fce] +#[marine] pub fn inner_arrays_2(_arg: Vec>>>) -> Vec>>> { unimplemented!() } -#[fce] +#[marine] pub fn string_type(_arg: Vec) -> Vec { unimplemented!() } -#[fce] +#[marine] pub fn bool_type(_arg: Vec) -> Vec { unimplemented!() } -#[fce] +#[marine] pub fn f32_type(_arg: Vec) -> Vec { unimplemented!() } -#[fce] +#[marine] pub fn f64_type(_arg: Vec) -> Vec { unimplemented!() } -#[fce] +#[marine] pub fn u32_type(_arg: Vec) -> Vec { unimplemented!() } -#[fce] +#[marine] pub fn u64_type(_arg: Vec) -> Vec { unimplemented!() } -#[fce] +#[marine] pub fn i32_type(_arg: Vec) -> Vec { unimplemented!() } -#[fce] +#[marine] pub fn i64_type(_arg: Vec) -> Vec { unimplemented!() } -#[fce] +#[marine] pub fn empty_type() -> Vec { unimplemented!() } diff --git a/fluence/tests/compilation_tests/export_functions/basic_types.rs b/fluence/tests/compilation_tests/export_functions/basic_types.rs index 107df72..745309a 100644 --- a/fluence/tests/compilation_tests/export_functions/basic_types.rs +++ b/fluence/tests/compilation_tests/export_functions/basic_types.rs @@ -1,10 +1,10 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; pub fn main() {} -#[fce] +#[marine] pub fn all_types( _arg_0: i8, _arg_1: i16, @@ -22,57 +22,57 @@ pub fn all_types( unimplemented!() } -#[fce] +#[marine] pub fn string_type(_arg: String) -> String { unimplemented!() } -#[fce] +#[marine] pub fn str_type(_arg: &str) -> &str { unimplemented!() } -#[fce] +#[marine] pub fn bytearray_type(_arg: Vec) -> Vec { unimplemented!() } -#[fce] +#[marine] pub fn bool_type(_arg: bool) -> bool { unimplemented!() } -#[fce] +#[marine] pub fn f32_type(_arg: f32) -> f32 { unimplemented!() } -#[fce] +#[marine] pub fn f64_type(_arg: f64) -> f64 { unimplemented!() } -#[fce] +#[marine] pub fn u32_type(_arg: u32) -> u32 { unimplemented!() } -#[fce] +#[marine] pub fn u64_type(_arg: u64) -> u64 { unimplemented!() } -#[fce] +#[marine] pub fn i32_type(_arg: i32) -> i32 { unimplemented!() } -#[fce] +#[marine] pub fn i64_type(_arg: i64) -> i64 { unimplemented!() } -#[fce] +#[marine] pub fn empty_type() -> String { unimplemented!() } diff --git a/fluence/tests/compilation_tests/export_functions/improper_types.rs b/fluence/tests/compilation_tests/export_functions/improper_types.rs index d2caa86..61b08f6 100644 --- a/fluence/tests/compilation_tests/export_functions/improper_types.rs +++ b/fluence/tests/compilation_tests/export_functions/improper_types.rs @@ -1,24 +1,24 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; pub fn main() {} -#[fce] +#[marine] fn test(_arg_1: Box) {} -#[fce] +#[marine] fn test2(_arg_1: std::rc::Rc) {} -#[fce] +#[marine] fn test3(_arg_1: std::collections::HashMap) {} -#[fce] +#[marine] fn test4(_arg_1: i32) -> (i32, i32) { unimplemented!() } -#[fce] +#[marine] fn test5(_arg_1: i32) -> Box { unimplemented!() } diff --git a/fluence/tests/compilation_tests/export_functions/inner_vec_refs.rs b/fluence/tests/compilation_tests/export_functions/inner_vec_refs.rs index cbc346a..448ac1d 100644 --- a/fluence/tests/compilation_tests/export_functions/inner_vec_refs.rs +++ b/fluence/tests/compilation_tests/export_functions/inner_vec_refs.rs @@ -1,11 +1,11 @@ #![allow(improper_ctypes)] -#[fce] +#[marine] pub fn inner_arrays_2(_arg: &Vec>>>) -> &Vec>>> { unimplemented!() } -#[fce] +#[marine] pub fn inner_arrays_3(_arg: &Vec>>>) -> &Vec<&Vec<&Vec<&Vec<&u8>>>> { unimplemented!() } diff --git a/fluence/tests/compilation_tests/export_functions/inner_vec_refs.stderr b/fluence/tests/compilation_tests/export_functions/inner_vec_refs.stderr index 0120a33..85ac160 100644 --- a/fluence/tests/compilation_tests/export_functions/inner_vec_refs.stderr +++ b/fluence/tests/compilation_tests/export_functions/inner_vec_refs.stderr @@ -1,13 +1,13 @@ -error: cannot find attribute `fce` in this scope +error: cannot find attribute `marine` in this scope --> $DIR/inner_vec_refs.rs:8:3 | -8 | #[fce] +8 | #[marine] | ^^^ -error: cannot find attribute `fce` in this scope +error: cannot find attribute `marine` in this scope --> $DIR/inner_vec_refs.rs:3:3 | -3 | #[fce] +3 | #[marine] | ^^^ error[E0601]: `main` function not found in crate `$CRATE` @@ -15,7 +15,7 @@ error[E0601]: `main` function not found in crate `$CRATE` | 1 | / #![allow(improper_ctypes)] 2 | | -3 | | #[fce] +3 | | #[marine] 4 | | pub fn inner_arrays_2(_arg: &Vec>>>) -> &Vec>>> { ... | 10 | | unimplemented!() diff --git a/fluence/tests/compilation_tests/export_functions/ref_arrays.rs b/fluence/tests/compilation_tests/export_functions/ref_arrays.rs index e984917..71e10f9 100644 --- a/fluence/tests/compilation_tests/export_functions/ref_arrays.rs +++ b/fluence/tests/compilation_tests/export_functions/ref_arrays.rs @@ -1,72 +1,72 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; pub fn main() {} -#[fce] +#[marine] pub fn byte_type(_arg: &Vec) -> &Vec { unimplemented!() } -#[fce] +#[marine] pub fn inner_arrays_1(_arg: &Vec>>>) -> &Vec>>> { unimplemented!() } -#[fce] +#[marine] #[derive(Default)] pub struct TestRecord { pub field_0: i32, pub field_1: Vec>, } -#[fce] +#[marine] pub fn inner_arrays_4(_arg: &Vec>>>) -> &Vec>>> { unimplemented!() } -#[fce] +#[marine] pub fn string_type(_arg: &Vec) -> &Vec { unimplemented!() } -#[fce] +#[marine] pub fn bool_type(_arg: &Vec) -> &Vec { unimplemented!() } -#[fce] +#[marine] pub fn f32_type(_arg: &Vec) -> &Vec { unimplemented!() } -#[fce] +#[marine] pub fn f64_type(_arg: &Vec) -> &Vec { unimplemented!() } -#[fce] +#[marine] pub fn u32_type(_arg: &Vec) -> &Vec { unimplemented!() } -#[fce] +#[marine] pub fn u64_type(_arg: &Vec) -> &Vec { unimplemented!() } -#[fce] +#[marine] pub fn i32_type(_arg: &Vec) -> &Vec { unimplemented!() } -#[fce] +#[marine] pub fn i64_type(_arg: &Vec) -> &Vec { unimplemented!() } -#[fce] +#[marine] pub fn empty_type() -> &'static Vec { unimplemented!() } diff --git a/fluence/tests/compilation_tests/export_functions/ref_basic_types.rs b/fluence/tests/compilation_tests/export_functions/ref_basic_types.rs index 1e2f2d0..05c15d4 100644 --- a/fluence/tests/compilation_tests/export_functions/ref_basic_types.rs +++ b/fluence/tests/compilation_tests/export_functions/ref_basic_types.rs @@ -1,10 +1,10 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; pub fn main() {} -#[fce] +#[marine] pub fn all_types<'v>( _arg_0: &i8, _arg_1: &i16, @@ -22,52 +22,52 @@ pub fn all_types<'v>( unimplemented!() } -#[fce] +#[marine] pub fn string_type(_arg: &String) -> &String { unimplemented!() } -#[fce] +#[marine] pub fn bytearray_type(_arg: &Vec) -> &Vec { unimplemented!() } -#[fce] +#[marine] pub fn bool_type(_arg: &bool) -> &bool { unimplemented!() } -#[fce] +#[marine] pub fn f32_type(_arg: &f32) -> &f32 { unimplemented!() } -#[fce] +#[marine] pub fn f64_type(_arg: &f64) -> &f64 { unimplemented!() } -#[fce] +#[marine] pub fn u32_type(_arg: &u32) -> &u32 { unimplemented!() } -#[fce] +#[marine] pub fn u64_type(_arg: &u64) -> &u64 { unimplemented!() } -#[fce] +#[marine] pub fn i32_type(_arg: &i32) -> &i32 { unimplemented!() } -#[fce] +#[marine] pub fn i64_type(_arg: &i64) -> &i64 { unimplemented!() } -#[fce] +#[marine] pub fn empty_type() -> &'static String { unimplemented!() } diff --git a/fluence/tests/compilation_tests/import_functions/arrays.rs b/fluence/tests/compilation_tests/import_functions/arrays.rs index 618b18e..ce63187 100644 --- a/fluence/tests/compilation_tests/import_functions/arrays.rs +++ b/fluence/tests/compilation_tests/import_functions/arrays.rs @@ -1,17 +1,17 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; pub fn main() {} -#[fce] +#[marine] #[derive(Default)] pub struct TestRecord { pub field_0: i32, pub field_1: Vec>, } -#[fce] +#[marine] #[link(wasm_import_module = "arrays_passing_effector")] extern "C" { pub fn inner_arrays_1(arg: Vec>>>) -> Vec>>>; diff --git a/fluence/tests/compilation_tests/import_functions/arrays_out_inner_refs.rs b/fluence/tests/compilation_tests/import_functions/arrays_out_inner_refs.rs index ba6079c..f2fa9dd 100644 --- a/fluence/tests/compilation_tests/import_functions/arrays_out_inner_refs.rs +++ b/fluence/tests/compilation_tests/import_functions/arrays_out_inner_refs.rs @@ -1,27 +1,27 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; pub fn main() {} -#[fce] +#[marine] #[link(wasm_import_module = "arrays_passing_effector")] extern "C" { - #[fce] + #[marine] pub fn func_1() -> &String; - #[fce] + #[marine] pub fn func_2() -> &Vec>>>; - #[fce] + #[marine] pub fn func_3() -> Vec<&Vec>>>; - #[fce] + #[marine] pub fn func_4() -> Vec>>>; - #[fce] + #[marine] pub fn func_5() -> Vec>>>; - #[fce] + #[marine] pub fn func_6() -> Vec>>>; } diff --git a/fluence/tests/compilation_tests/import_functions/arrays_out_inner_refs.stderr b/fluence/tests/compilation_tests/import_functions/arrays_out_inner_refs.stderr index 07a124c..59a635e 100644 --- a/fluence/tests/compilation_tests/import_functions/arrays_out_inner_refs.stderr +++ b/fluence/tests/compilation_tests/import_functions/arrays_out_inner_refs.stderr @@ -1,6 +1,6 @@ error: import function can't return a value with references --> $DIR/arrays_out_inner_refs.rs:10:5 | -10 | / #[fce] +10 | / #[marine] 11 | | pub fn func_1() -> &String; | |_______________________________^ diff --git a/fluence/tests/compilation_tests/import_functions/basic_ref_types.rs b/fluence/tests/compilation_tests/import_functions/basic_ref_types.rs index 7972815..d4b3b73 100644 --- a/fluence/tests/compilation_tests/import_functions/basic_ref_types.rs +++ b/fluence/tests/compilation_tests/import_functions/basic_ref_types.rs @@ -1,10 +1,10 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; fn main() {} -#[fce] +#[marine] #[link(wasm_import_module = "arguments_passing_effector")] extern "C" { pub fn all_ref_types( diff --git a/fluence/tests/compilation_tests/import_functions/basic_types.rs b/fluence/tests/compilation_tests/import_functions/basic_types.rs index 340a5d2..98253d0 100644 --- a/fluence/tests/compilation_tests/import_functions/basic_types.rs +++ b/fluence/tests/compilation_tests/import_functions/basic_types.rs @@ -1,10 +1,10 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; fn main() {} -#[fce] +#[marine] #[link(wasm_import_module = "arguments_passing_effector")] extern "C" { pub fn all_types( diff --git a/fluence/tests/compilation_tests/import_functions/improper_types.rs b/fluence/tests/compilation_tests/import_functions/improper_types.rs index 5888828..30bfece 100644 --- a/fluence/tests/compilation_tests/import_functions/improper_types.rs +++ b/fluence/tests/compilation_tests/import_functions/improper_types.rs @@ -1,24 +1,24 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; pub fn main() {} -#[fce] +#[marine] #[link(wasm_import_module = "arguments_passing_effector")] extern "C" { - #[fce] + #[marine] fn test(_arg_1: Box); - #[fce] + #[marine] fn test2(_arg_1: std::rc::Rc); - #[fce] + #[marine] fn test3(_arg_1: std::collections::HashMap); - #[fce] + #[marine] fn test4(_arg_1: i32) -> (i32, i32); - #[fce] + #[marine] fn test5(_arg_1: i32) -> Box; } diff --git a/fluence/tests/compilation_tests/import_functions/ref_arrays.rs b/fluence/tests/compilation_tests/import_functions/ref_arrays.rs index eb6a542..ae32e00 100644 --- a/fluence/tests/compilation_tests/import_functions/ref_arrays.rs +++ b/fluence/tests/compilation_tests/import_functions/ref_arrays.rs @@ -1,17 +1,17 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; pub fn main() {} -#[fce] +#[marine] #[derive(Default)] pub struct TestRecord { pub field_0: i32, pub field_1: Vec>, } -#[fce] +#[marine] #[link(wasm_import_module = "arrays_passing_effector")] extern "C" { pub fn inner_arrays_1(arg: &Vec>>>) -> Vec>>>; diff --git a/fluence/tests/compilation_tests/import_functions/ref_basic_types.rs b/fluence/tests/compilation_tests/import_functions/ref_basic_types.rs index f7c2ecb..d8df55f 100644 --- a/fluence/tests/compilation_tests/import_functions/ref_basic_types.rs +++ b/fluence/tests/compilation_tests/import_functions/ref_basic_types.rs @@ -1,10 +1,10 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; fn main() {} -#[fce] +#[marine] #[link(wasm_import_module = "arguments_passing_effector")] extern "C" { pub fn all_types( diff --git a/fluence/tests/compilation_tests/records/basic_structs.rs b/fluence/tests/compilation_tests/records/basic_structs.rs index b1daa76..bf8c9e7 100644 --- a/fluence/tests/compilation_tests/records/basic_structs.rs +++ b/fluence/tests/compilation_tests/records/basic_structs.rs @@ -1,8 +1,8 @@ -use fluence::fce; +use fluence::marine; fn main() {} -#[fce] +#[marine] pub struct TestRecord { pub field_0: bool, pub field_1: i8, @@ -19,7 +19,7 @@ pub struct TestRecord { pub field_12: Vec, } -#[fce] +#[marine] pub struct Tx { pub block_hash: String, pub block_number: String, @@ -34,7 +34,7 @@ pub struct Tx { pub value: String, } -#[fce] +#[marine] #[derive(Debug)] pub struct JsonRpcResult { pub json_rpc: String, @@ -43,7 +43,7 @@ pub struct JsonRpcResult { pub id: u64, } -#[fce] +#[marine] #[derive(Clone, Debug, Default, Eq, PartialEq, Hash)] pub struct User { pub peer_id: String, @@ -52,27 +52,27 @@ pub struct User { pub name: String, } -#[fce] +#[marine] pub struct GetUsersServiceResult { pub ret_code: i32, pub err_msg: String, pub users: Vec, } -#[fce] +#[marine] pub struct EmptyServiceResult { pub ret_code: i32, pub err_msg: String, } -#[fce] +#[marine] pub struct ExistsServiceResult { pub ret_code: i32, pub err_msg: String, pub is_exists: bool, } -#[fce] +#[marine] pub struct AuthResult { pub ret_code: i32, pub err_msg: String, diff --git a/fluence/tests/compilation_tests/records/empty_struct.rs b/fluence/tests/compilation_tests/records/empty_struct.rs index 86e72e2..e138e62 100644 --- a/fluence/tests/compilation_tests/records/empty_struct.rs +++ b/fluence/tests/compilation_tests/records/empty_struct.rs @@ -1,6 +1,6 @@ -use fluence::fce; +use fluence::marine; fn main() {} -#[fce] +#[marine] struct A {} diff --git a/fluence/tests/compilation_tests/records/struct_with_improper_types.rs b/fluence/tests/compilation_tests/records/struct_with_improper_types.rs index f8743dc..998e805 100644 --- a/fluence/tests/compilation_tests/records/struct_with_improper_types.rs +++ b/fluence/tests/compilation_tests/records/struct_with_improper_types.rs @@ -1,18 +1,18 @@ -use fluence::fce; +use fluence::marine; fn main() {} -#[fce] +#[marine] struct StructWithBox { pub a: Box, } -#[fce] +#[marine] struct StructWithRc { pub a: std::rc::Rc, } -#[fce] +#[marine] struct StructWithHashMap { pub a: std::collections::HashMap, } diff --git a/fluence/tests/compilation_tests/records/struct_with_private_fields.rs b/fluence/tests/compilation_tests/records/struct_with_private_fields.rs index ca4f2aa..8823eaf 100644 --- a/fluence/tests/compilation_tests/records/struct_with_private_fields.rs +++ b/fluence/tests/compilation_tests/records/struct_with_private_fields.rs @@ -1,10 +1,10 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; fn main() {} -#[fce] +#[marine] struct StructWithPrivateFields { a: i32, b: usize, diff --git a/fluence/tests/compilation_tests/records/struct_with_private_fields.stderr b/fluence/tests/compilation_tests/records/struct_with_private_fields.stderr index 22b2d15..32386a1 100644 --- a/fluence/tests/compilation_tests/records/struct_with_private_fields.stderr +++ b/fluence/tests/compilation_tests/records/struct_with_private_fields.stderr @@ -1,4 +1,4 @@ -error: #[fce] could be applied only to struct with all public fields +error: #[marine] could be applied only to struct with all public fields --> $DIR/struct_with_private_fields.rs:9:5 | 9 | a: i32, diff --git a/fluence/tests/compilation_tests/records/unnamed_structs.rs b/fluence/tests/compilation_tests/records/unnamed_structs.rs index 593069d..8c8fb62 100644 --- a/fluence/tests/compilation_tests/records/unnamed_structs.rs +++ b/fluence/tests/compilation_tests/records/unnamed_structs.rs @@ -1,8 +1,8 @@ #![allow(improper_ctypes)] -use fluence::fce; +use fluence::marine; fn main() {} -#[fce] +#[marine] struct A(pub i32, pub u32); diff --git a/fluence/tests/compilation_tests_runner.rs b/fluence/tests/compilation_tests_runner.rs index c6ab271..77e63d2 100644 --- a/fluence/tests/compilation_tests_runner.rs +++ b/fluence/tests/compilation_tests_runner.rs @@ -1,5 +1,5 @@ #[test] -fn fce_compilation_tests() { +fn marine_compilation_tests() { let tests = trybuild::TestCases::new(); tests.compile_fail("tests/compilation_tests/export_functions/array_inner_refs.rs"); tests.pass("tests/compilation_tests/export_functions/arrays.rs");