StardustXR/server
1
0
Fork 0
Code Issues 11 Pull Requests 3 Actions Packages Projects Releases 5 Wiki Activity

fix(codegen): make enums u32s over the wire

Browse Source
This commit is contained in:
Nova
2024-02-04 17:10:38 -05:00
parent b8d17ac7ca
commit dfaaa2a3a9
2 changed files with 70 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.lock generated
View File

@@ -2063,7 +2063,7 @@ checksum = "2f2b15926089e5526bb2dd738a2eb0e59034356e06eb71e1cd912358c0e62c4d"
[[package]] [[package]]
name = "stardust-xr" name = "stardust-xr"
version = "0.14.1" version = "0.14.1"
source = "git+https://github.com/StardustXR/core.git?branch=feat/idl#530b1fe5aa33f782fbf28026410ba00dd23da16d" source = "git+https://github.com/StardustXR/core.git?branch=feat/idl#451181bfd454f30861bf310742bf7a16bdb36264"
dependencies = [ dependencies = [
"cluFlock", "cluFlock",
"color-rs", "color-rs",
@@ -2083,7 +2083,7 @@ dependencies = [
[[package]] [[package]]
name = "stardust-xr-schemas" name = "stardust-xr-schemas"
version = "1.5.3" version = "1.5.3"
source = "git+https://github.com/StardustXR/core.git?branch=feat/idl#530b1fe5aa33f782fbf28026410ba00dd23da16d" source = "git+https://github.com/StardustXR/core.git?branch=feat/idl#451181bfd454f30861bf310742bf7a16bdb36264"
dependencies = [ dependencies = [
"flatbuffers", "flatbuffers",
"flexbuffers", "flexbuffers",

127
codegen/src/lib.rs
View File

@@ -105,7 +105,8 @@ fn generate_custom_enum(custom_enum: &CustomEnum) -> TokenStream {
quote! { quote! {
#[doc = #description] #[doc = #description]
#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)] #[derive(Debug, Clone, Copy, serde_repr::Deserialize_repr, serde_repr::Serialize_repr)]
#[repr(u32)]
pub enum #name {#argument_decls} pub enum #name {#argument_decls}
} }
} }
@@ -139,7 +140,7 @@ fn generate_union_option(union_option: &UnionOption) -> TokenStream {
.map(|d| quote!(#[doc = #d])) .map(|d| quote!(#[doc = #d]))
.unwrap_or_default(); .unwrap_or_default();
let identifier = Ident::new(&name, Span::call_site()); let identifier = Ident::new(&name, Span::call_site());
let _type = generate_argument_type(&union_option._type, true); let _type = generate_argument_type(&union_option._type, false, true);
quote! (#description #identifier(#_type)) quote! (#description #identifier(#_type))
} }
fn generate_custom_struct(custom_struct: &CustomStruct) -> TokenStream { fn generate_custom_struct(custom_struct: &CustomStruct) -> TokenStream {
@@ -161,44 +162,44 @@ fn generate_custom_struct(custom_struct: &CustomStruct) -> TokenStream {
} }
} }
fn generate_node(node: &Node) -> TokenStream { // fn generate_node(node: &Node) -> TokenStream {
let node_name = Ident::new(&node.name, Span::call_site()); // let node_name = Ident::new(&node.name, Span::call_site());
let description = &node.description; // let description = &node.description;
let aspects = node // let aspects = node
.aspects // .aspects
.iter() // .iter()
.map(|a| { // .map(|a| {
let aspect_name = Ident::new(&format!("{a}Aspect"), Span::call_site()); // let aspect_name = Ident::new(&format!("{a}Aspect"), Span::call_site());
quote!(impl #aspect_name for #node_name {}) // quote!(impl #aspect_name for #node_name {})
}) // })
.reduce(fold_tokens) // .reduce(fold_tokens)
.unwrap_or_default(); // .unwrap_or_default();
quote! { // quote! {
#[doc = #description] // #[doc = #description]
#[derive(Debug)] // #[derive(Debug)]
pub struct #node_name (crate::node::Node); // pub struct #node_name (crate::node::Node);
impl crate::node::NodeType for #node_name { // impl crate::node::NodeType for #node_name {
fn node(&self) -> &crate::node::Node { // fn node(&self) -> &crate::node::Node {
&self.0 // &self.0
} // }
fn alias(&self) -> Self { // fn alias(&self) -> Self {
#node_name(self.0.alias()) // #node_name(self.0.alias())
} // }
fn from_path(client: &std::sync::Arc<crate::client::Client>, path: String, destroyable: bool) -> Self { // fn from_path(client: &std::sync::Arc<crate::client::Client>, path: String, destroyable: bool) -> Self {
#node_name(crate::node::Node::from_path(client, path, destroyable)) // #node_name(crate::node::Node::from_path(client, path, destroyable))
} // }
} // }
impl serde::Serialize for #node_name { // impl serde::Serialize for #node_name {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { // fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let node_path = self.0.get_path().map_err(|e| serde::ser::Error::custom(e))?; // let node_path = self.0.get_path().map_err(|e| serde::ser::Error::custom(e))?;
serializer.serialize_str(&node_path) // serializer.serialize_str(&node_path)
} // }
} // }
#aspects // #aspects
} // }
} // }
fn generate_aspect(aspect: &Aspect) -> TokenStream { fn generate_aspect(aspect: &Aspect) -> TokenStream {
let description = &aspect.description; let description = &aspect.description;
@@ -252,10 +253,6 @@ fn generate_aspect(aspect: &Aspect) -> TokenStream {
quote!(#client_side_members #server_side_members) quote!(#client_side_members #server_side_members)
} }
fn generate_interface_member(interface_path: &str, member: &Member) -> TokenStream {
Default::default()
}
fn generate_member(member: &Member) -> TokenStream { fn generate_member(member: &Member) -> TokenStream {
let name_str = &member.name; let name_str = &member.name;
let name = Ident::new(&member.name.to_case(Case::Snake), Span::call_site()); let name = Ident::new(&member.name.to_case(Case::Snake), Span::call_site());
@@ -285,7 +282,7 @@ fn generate_member(member: &Member) -> TokenStream {
let return_type = member let return_type = member
.return_type .return_type
.as_ref() .as_ref()
.map(|r| generate_argument_type(&r, true)) .map(|r| generate_argument_type(&r, false, true))
.unwrap_or_else(|| quote!(())); .unwrap_or_else(|| quote!(()));
match (side, _type) { match (side, _type) {
@@ -348,9 +345,10 @@ fn generate_handler(member: &Member) -> TokenStream {
let argument_types = member let argument_types = member
.arguments .arguments
.iter() .iter()
.map(|a| &a._type) .map(|a| {
.map(convert_deserializeable_argument_type) let _type = convert_deserializeable_argument_type(&a._type);
.map(|a| generate_argument_type(&a, true)) generate_argument_type(&_type, a.optional, true)
})
.reduce(|a, b| quote!(#a, #b)); .reduce(|a, b| quote!(#a, #b));
// dbg!(&argument_types); // dbg!(&argument_types);
let deserialize = argument_names let deserialize = argument_names
@@ -408,11 +406,11 @@ fn generate_argument_deserialize(
ArgumentType::Color => quote!(color::rgba_linear!(#name[0], #name[1], #name[2], #name[3])), ArgumentType::Color => quote!(color::rgba_linear!(#name[0], #name[1], #name[2], #name[3])),
ArgumentType::Vec(v) => { ArgumentType::Vec(v) => {
let mapping = generate_argument_deserialize("a", v, false); let mapping = generate_argument_deserialize("a", v, false);
quote!(#name.iter().map(|a| Ok(#mapping)).collect::<color_eyre::eyre::Result<Vec<_>>>()?) quote!(#name.into_iter().map(|a| Ok(#mapping)).collect::<color_eyre::eyre::Result<Vec<_>>>()?)
} }
ArgumentType::Map(v) => { ArgumentType::Map(v) => {
let mapping = generate_argument_deserialize("a", v, false); let mapping = generate_argument_deserialize("a", v, false);
quote!(#name.iter().map(|(k, a)| Ok((k, #mapping))).collect::<color_eyre::eyre::Result<rustc_hash::FxHashMap<String, _>>>()?) quote!(#name.into_iter().map(|(k, a)| Ok((k, #mapping))).collect::<color_eyre::eyre::Result<rustc_hash::FxHashMap<String, _>>>()?)
} }
_ => quote!(#name), _ => quote!(#name),
} }
@@ -434,21 +432,18 @@ fn generate_argument_serialize(
ArgumentType::Color => quote!([#name.c.r, #name.c.g, #name.c.b, #name.a]), ArgumentType::Color => quote!([#name.c.r, #name.c.g, #name.c.b, #name.a]),
ArgumentType::Vec(v) => { ArgumentType::Vec(v) => {
let mapping = generate_argument_serialize("a", v, false); let mapping = generate_argument_serialize("a", v, false);
quote!(#name.iter().map(|a| Ok(#mapping)).collect::<color_eyre::eyre::Result<Vec<_>>>()?) quote!(#name.into_iter().map(|a| Ok(#mapping)).collect::<color_eyre::eyre::Result<Vec<_>>>()?)
} }
ArgumentType::Map(v) => { ArgumentType::Map(v) => {
let mapping = generate_argument_serialize("a", v, false); let mapping = generate_argument_serialize("a", v, false);
quote!(#name.iter().map(|(k, a)| Ok((k, #mapping))).collect::<color_eyre::eyre::Result<rustc_hash::FxHashMap<String, _>>>()?) quote!(#name.into_iter().map(|(k, a)| Ok((k, #mapping))).collect::<color_eyre::eyre::Result<rustc_hash::FxHashMap<String, _>>>()?)
} }
_ => quote!(#name), _ => quote!(#name),
} }
} }
fn generate_argument_decl(argument: &Argument, owned_values: bool) -> TokenStream { fn generate_argument_decl(argument: &Argument, owned_values: bool) -> TokenStream {
let name = Ident::new(&argument.name.to_case(Case::Snake), Span::call_site()); let name = Ident::new(&argument.name.to_case(Case::Snake), Span::call_site());
let mut _type = generate_argument_type(&argument._type, owned_values); let mut _type = generate_argument_type(&argument._type, argument.optional, owned_values);
if argument.optional {
_type = quote!(Option<#_type>);
}
quote!(#name: #_type) quote!(#name: #_type)
} }
fn argument_type_option_name(argument_type: &ArgumentType) -> String { fn argument_type_option_name(argument_type: &ArgumentType) -> String {
@@ -473,8 +468,12 @@ fn argument_type_option_name(argument_type: &ArgumentType) -> String {
ArgumentType::Node { _type, .. } => _type.clone(), ArgumentType::Node { _type, .. } => _type.clone(),
} }
} }
fn generate_argument_type(argument_type: &ArgumentType, owned: bool) -> TokenStream { fn generate_argument_type(
match argument_type { argument_type: &ArgumentType,
optional: bool,
owned: bool,
) -> TokenStream {
let _type = match argument_type {
ArgumentType::Bool => quote!(bool), ArgumentType::Bool => quote!(bool),
ArgumentType::Int => quote!(i32), ArgumentType::Int => quote!(i32),
ArgumentType::UInt => quote!(u32), ArgumentType::UInt => quote!(u32),
@@ -498,7 +497,7 @@ fn generate_argument_type(argument_type: &ArgumentType, owned: bool) -> TokenStr
} }
} }
ArgumentType::Vec(t) => { ArgumentType::Vec(t) => {
let t = generate_argument_type(&t, true); let t = generate_argument_type(&t, false, true);
if !owned { if !owned {
quote!(&[#t]) quote!(&[#t])
} else { } else {
@@ -506,7 +505,7 @@ fn generate_argument_type(argument_type: &ArgumentType, owned: bool) -> TokenStr
} }
} }
ArgumentType::Map(t) => { ArgumentType::Map(t) => {
let t = generate_argument_type(&t, true); let t = generate_argument_type(&t, false, true);
if !owned { if !owned {
quote!(&rustc_hash::FxHashMap<String, #t>) quote!(&rustc_hash::FxHashMap<String, #t>)
@@ -538,7 +537,11 @@ fn generate_argument_type(argument_type: &ArgumentType, owned: bool) -> TokenStr
} }
ArgumentType::Struct(s) => { ArgumentType::Struct(s) => {
let struct_name = Ident::new(&s.to_case(Case::Pascal), Span::call_site()); let struct_name = Ident::new(&s.to_case(Case::Pascal), Span::call_site());
quote!(#struct_name) if !owned {
quote!(&#struct_name)
} else {
quote!(#struct_name)
}
} }
ArgumentType::Node { ArgumentType::Node {
_type, _type,
@@ -550,5 +553,11 @@ fn generate_argument_type(argument_type: &ArgumentType, owned: bool) -> TokenStr
quote!(std::sync::Arc<crate::nodes::Node>) quote!(std::sync::Arc<crate::nodes::Node>)
} }
} }
};
if optional {
quote!(Option<#_type>)
} else {
_type
} }
} }