fluencelabs/marine-rs-sdk-test
1
0
Fork 0
mirror of https://github.com/fluencelabs/marine-rs-sdk-test synced 2025-04-24 23:12:13 +00:00
Code Issues Projects Releases Wiki Activity

replace WasmTYpe with RustType

Browse Source
This commit is contained in:
vms 2020-09-10 20:39:11 +03:00
parent 5db70ea665
commit 2c461b4350
7 changed files with 50 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/wit/src/lib.rs
View File

@ -44,4 +44,4 @@ pub use parsed_type::ParsedType;
pub use token_stream_generator::GENERATED_WRAPPER_FUNC_PREFIX;
pub use token_stream_generator::GENERATED_SECTION_PREFIX;
pub use token_stream_generator::GENERATED_GLOBAL_PREFIX;
pub use wasm_type::WasmType;
pub use wasm_type::RustType;

31
crates/wit/src/parsed_type/fn_arg.rs
View File

@ -15,28 +15,29 @@
*/
use super::ParsedType;
use crate::wasm_type::WasmType;
use crate::wasm_type::RustType;
/// This trait could be used to generate raw args needed to construct a export function.
pub(crate) trait FnArgGlueCodeGenerator {
fn generate_arguments(&self) -> Vec<WasmType>;
fn generate_arguments(&self) -> Vec<RustType>;
}
impl FnArgGlueCodeGenerator for (String, ParsedType) {
fn generate_arguments(&self) -> Vec<WasmType> {
fn generate_arguments(&self) -> Vec<RustType> {
match self.1 {
ParsedType::Boolean
| ParsedType::I8
| ParsedType::I16
| ParsedType::I32
| ParsedType::U8
| ParsedType::U16
| ParsedType::U32
| ParsedType::Record(_) => vec![WasmType::I32],
ParsedType::I64 | ParsedType::U64 => vec![WasmType::I64],
ParsedType::F32 => vec![WasmType::F32],
ParsedType::F64 => vec![WasmType::F64],
ParsedType::Utf8String | ParsedType::ByteVector => vec![WasmType::I32, WasmType::I32],
ParsedType::Boolean => vec![RustType::I32],
ParsedType::I8 => vec![RustType::I8],
ParsedType::I16 => vec![RustType::I16],
ParsedType::I32 => vec![RustType::I32],
ParsedType::I64 => vec![RustType::I64],
ParsedType::U8 => vec![RustType::U8],
ParsedType::U16 => vec![RustType::U16],
ParsedType::U32 => vec![RustType::U32],
ParsedType::U64 => vec![RustType::U64],
ParsedType::Record(_) => vec![RustType::U32],
ParsedType::F32 => vec![RustType::F32],
ParsedType::F64 => vec![RustType::F64],
ParsedType::Utf8String | ParsedType::ByteVector => vec![RustType::U32, RustType::U32],
}
}
}

20
crates/wit/src/parsed_type/fn_epilog.rs
View File

@ -53,19 +53,17 @@ impl FnEpilogGlueCodeGenerator for Option<ParsedType> {
fn generate_fn_return_type(ty: &Option<ParsedType>) -> proc_macro2::TokenStream {
let ty = match ty {
Some(ParsedType::Boolean)
| Some(ParsedType::I8)
| Some(ParsedType::I16)
| Some(ParsedType::I32)
| Some(ParsedType::U8)
| Some(ParsedType::U16)
| Some(ParsedType::U32) => Some("i32"),
Some(ParsedType::I64) | Some(ParsedType::U64) => Some("i64"),
Some(ParsedType::Boolean) => Some("i32"),
Some(ParsedType::I8) => Some("i8"),
Some(ParsedType::I16) => Some("i16"),
Some(ParsedType::I32) => Some("i32"),
Some(ParsedType::I64) => Some("i64"),
Some(ParsedType::U8) => Some("u8"),
Some(ParsedType::U16) => Some("u16"),
Some(ParsedType::U32) => Some("u32"),
Some(ParsedType::U64) => Some("u64"),
Some(ParsedType::F32) => Some("f32"),
Some(ParsedType::F64) => Some("f64"),
None
| Some(ParsedType::Utf8String)
| Some(ParsedType::ByteVector)

4
crates/wit/src/parsed_type/fn_prolog.rs
View File

@ -17,14 +17,14 @@
use super::ParsedType;
use super::FnArgGlueCodeGenerator;
use crate::new_ident;
use crate::wasm_type::WasmType;
use crate::wasm_type::RustType;
use quote::quote;
/// Describes various parts of a function prolog.
pub(crate) struct FnPrologDescriptor {
pub(crate) raw_arg_names: Vec<syn::Ident>,
pub(crate) raw_arg_types: Vec<WasmType>,
pub(crate) raw_arg_types: Vec<RustType>,
pub(crate) prolog: proc_macro2::TokenStream,
pub(crate) args: Vec<syn::Ident>,
}

1
crates/wit/src/parsed_type/foreign_mod_arg.rs
View File

@ -36,6 +36,7 @@ impl ForeignModArgGlueCodeGenerator for ParsedType {
#arg.__fce_generated_serialize() as _
}
}
ParsedType::Boolean => quote! { #arg as _ },
_ => quote! { #arg },
}
}

6
crates/wit/src/parsed_type/foreign_mod_prolog.rs
View File

@ -15,7 +15,7 @@
*/
use super::ParsedType;
use crate::wasm_type::WasmType;
use crate::wasm_type::RustType;
use crate::new_ident;
pub(crate) struct WrapperDescriptor {
@ -28,7 +28,7 @@ pub(crate) struct WrapperDescriptor {
pub(crate) struct ExternDescriptor {
pub(crate) raw_arg_names: Vec<syn::Ident>,
pub(crate) raw_arg_types: Vec<WasmType>,
pub(crate) raw_arg_types: Vec<RustType>,
}
/// This trait could be used to generate various parts needed to construct prolog of an wrapper
@ -99,7 +99,7 @@ impl ForeignModPrologGlueCodeGenerator for Vec<(String, ParsedType)> {
fn generate_extern_prolog(&self) -> ExternDescriptor {
use crate::parsed_type::FnArgGlueCodeGenerator;
let raw_arg_types: Vec<WasmType> = self
let raw_arg_types: Vec<RustType> = self
.iter()
.map(|input_type| input_type.generate_arguments())
.flatten()

24
crates/wit/src/wasm_type.rs
View File

@ -1,21 +1,33 @@
use proc_macro2::TokenStream;
/// Raw Wasm types according to the spec except i128.
pub enum WasmType {
pub enum RustType {
U8,
U16,
U32,
U64,
I8,
I16,
I32,
I64,
F32,
F64,
}
impl quote::ToTokens for WasmType {
impl quote::ToTokens for RustType {
fn to_tokens(&self, tokens: &mut TokenStream) {
let call_site = proc_macro2::Span::call_site();
match self {
WasmType::I32 => syn::Ident::new("i32", call_site).to_tokens(tokens),
WasmType::I64 => syn::Ident::new("i64", call_site).to_tokens(tokens),
WasmType::F32 => syn::Ident::new("f32", call_site).to_tokens(tokens),
WasmType::F64 => syn::Ident::new("f64", call_site).to_tokens(tokens),
RustType::U8 => syn::Ident::new("u8", call_site).to_tokens(tokens),
RustType::U16 => syn::Ident::new("u16", call_site).to_tokens(tokens),
RustType::U32 => syn::Ident::new("u32", call_site).to_tokens(tokens),
RustType::U64 => syn::Ident::new("u64", call_site).to_tokens(tokens),
RustType::I8 => syn::Ident::new("i8", call_site).to_tokens(tokens),
RustType::I16 => syn::Ident::new("i16", call_site).to_tokens(tokens),
RustType::I32 => syn::Ident::new("i32", call_site).to_tokens(tokens),
RustType::I64 => syn::Ident::new("i64", call_site).to_tokens(tokens),
RustType::F32 => syn::Ident::new("f32", call_site).to_tokens(tokens),
RustType::F64 => syn::Ident::new("f64", call_site).to_tokens(tokens),
}
}
}