Complete node output destructuring implementation

Author: JustJ01

node-graph/gcore/src/registry.rs

@@ -59,14 +59,7 @@ pub struct StructField {
 }
 
 pub trait Destruct {
-	fn fields(&self) -> &'static [StructField];
-}
-
-impl<T> Destruct for &T
-where
-	T: Default,
-{
-	fn fields(&self) -> &'static [StructField] {
+	fn fields() -> &'static [StructField] {
 		&[]
 	}
 }

node-graph/node-macro/src/codegen.rs

@@ -253,8 +253,8 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 	let properties = &attributes.properties_string.as_ref().map(|value| quote!(Some(#value))).unwrap_or(quote!(None));
 
 	let output_fields = match attributes.deconstruct_output {
-		false => quote!(&[]),
-		true => quote!(#output_type::fields),
+		false => quote!(&[] as &[#graphene_core::registry::StructField]),
+		true => quote!(<#output_type as #graphene_core::registry::Destruct>::fields()),
 	};
 
 	let node_input_accessor = generate_node_input_references(parsed, fn_generics, &field_idents, &graphene_core, &identifier);
@@ -377,7 +377,7 @@ fn generate_node_input_references(parsed: &ParsedNodeFn, fn_generics: &[crate::G
 			impl <#(#used),*> #graphene_core::NodeInputDecleration for #struct_name <#(#fn_generic_params),*> {
 				const INDEX: usize = #input_index;
 				fn identifier() -> &'static str {
-					#identifier
+					protonode_identifier()
 				}
 				type Result = #ty;
 			}
@@ -387,6 +387,14 @@ fn generate_node_input_references(parsed: &ParsedNodeFn, fn_generics: &[crate::G
 	quote! {
 		pub mod #inputs_module_name {
 			use super::*;
+
+			pub fn protonode_identifier() -> &'static str {
+				static NODE_NAME: std::sync::OnceLock<&'static str> = std::sync::OnceLock::new();
+				NODE_NAME.get_or_init(|| {
+					let name = #identifier;
+					Box::leak(name.into_boxed_str())
+				})
+			}
 			#(#generated_input_accessor)*
 		}
 	}

node-graph/node-macro/src/destruct.rs

@@ -1,54 +1,127 @@
-use proc_macro2::TokenStream as TokenStream2;
-use quote::quote;
-use syn::{Error, Ident, spanned::Spanned};
+use convert_case::{Case, Casing};
+use proc_macro_crate::FoundCrate;
+use proc_macro2::{Span, TokenStream as TokenStream2};
+use quote::{format_ident, quote};
+use syn::{Data, DeriveInput, Error, LitStr, Meta, Type, spanned::Spanned};
 
-pub fn derive(struct_name: Ident, data: syn::Data) -> syn::Result<TokenStream2> {
-	let syn::Data::Struct(data_struct) = data else {
-		return Err(Error::new(proc_macro2::Span::call_site(), String::from("Deriving `Destruct` is currently only supported for structs")));
+pub fn derive(input: DeriveInput) -> syn::Result<TokenStream2> {
+	let struct_name = input.ident;
+	let generics = input.generics;
+	let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+	let Data::Struct(data_struct) = input.data else {
+		return Err(Error::new(
+			Span::call_site(),
+			"Deriving `Destruct` is currently only supported for structs",
+		));
 	};
 
-	let crate_name = proc_macro_crate::crate_name("graphene-core").map_err(|e| {
+	let graphene_core = match proc_macro_crate::crate_name("graphene-core").map_err(|e| {
 		Error::new(
-			proc_macro2::Span::call_site(),
-			format!("Failed to find location of graphene_core. Make sure it is imported as a dependency: {}", e),
+			Span::call_site(),
+			format!("Failed to find location of graphene_core. Make sure it is imported as a dependency: {e}"),
 		)
-	})?;
-
-	let path = quote!(std::module_path!().rsplit_once("::").unwrap().0);
+	})? {
+		FoundCrate::Itself => quote!(crate),
+		FoundCrate::Name(name) => {
+			let ident = syn::Ident::new(&name, Span::call_site());
+			quote!(#ident)
+		}
+	};
 
 	let mut node_implementations = Vec::with_capacity(data_struct.fields.len());
-	let mut field_structs = Vec::with_capacity(data_struct.fields.len());
+	let mut output_fields = Vec::with_capacity(data_struct.fields.len());
 
 	for field in data_struct.fields {
 		let Some(field_name) = field.ident else {
-			return Err(Error::new(field.span(), String::from("Destruct cant be used on tuple structs")));
+			return Err(Error::new(field.span(), "Destruct cannot be used on tuple structs"));
 		};
+
 		let ty = field.ty;
-		let fn_name = quote::format_ident!("extract_ {field_name}");
-		node_implementations.push(quote! {
-			#[node_macro(category(""))]
-			fn #fn_name(_: impl Ctx, data: #struct_name) -> #ty {
-				data.#field_name
-			}
-		});
+		let output_name = parse_output_name(&field.attrs)?.unwrap_or_else(|| field_name.to_string().to_case(Case::Title));
+		let output_name_lit = LitStr::new(&output_name, field_name.span());
 
-		field_structs.push(quote! {
-			#crate_name::registry::FieldStruct {
-				name: stringify!(#field_name),
-				node_path: concat!()
+		let fn_name = format_ident!("extract_{}_{}", struct_name.to_string().to_case(Case::Snake), field_name);
+		let node_struct_name = format_ident!("{}Node", fn_name.to_string().to_case(Case::Pascal));
 
+		node_implementations.push(generate_extractor_node(&graphene_core, &fn_name, &struct_name, &field_name, &ty, &output_name_lit));
+		output_fields.push(quote! {
+			#graphene_core::registry::StructField {
+				name: #output_name_lit,
+				node_path: concat!(std::module_path!().rsplit_once("::").unwrap().0, "::", stringify!(#node_struct_name)),
+				ty: #graphene_core::concrete!(#ty),
 			}
-		})
+		});
 	}
 
 	Ok(quote! {
-		impl graphene_core::registry::Destruct for #struct_name {
-			fn fields() -> &[graphene_core::registry::FieldStruct] {
-				&[
+		#(#node_implementations)*
 
+		impl #impl_generics #graphene_core::registry::Destruct for #struct_name #ty_generics #where_clause {
+			fn fields() -> &'static [#graphene_core::registry::StructField] {
+				&[
+					#(#output_fields,)*
 				]
 			}
 		}
-
 	})
 }
+
+fn generate_extractor_node(
+	graphene_core: &TokenStream2,
+	fn_name: &syn::Ident,
+	struct_name: &syn::Ident,
+	field_name: &syn::Ident,
+	ty: &Type,
+	output_name: &LitStr,
+) -> TokenStream2 {
+	quote! {
+		#[node_macro::node(category(""), name(#output_name))]
+		fn #fn_name(_: impl #graphene_core::Ctx, data: #struct_name) -> #ty {
+			data.#field_name
+		}
+	}
+}
+
+fn parse_output_name(attrs: &[syn::Attribute]) -> syn::Result<Option<String>> {
+	let mut output_name = None;
+
+	for attr in attrs {
+		if !attr.path().is_ident("output") {
+			continue;
+		}
+
+		let mut this_output_name = None;
+		match &attr.meta {
+			Meta::Path(_) => {
+				return Err(Error::new_spanned(attr, "Expected output metadata like #[output(name = \"Result\")]"));
+			}
+			Meta::NameValue(_) => {
+				return Err(Error::new_spanned(attr, "Expected output metadata like #[output(name = \"Result\")]"));
+			}
+			Meta::List(_) => {
+				attr.parse_nested_meta(|meta| {
+					if meta.path.is_ident("name") {
+						if this_output_name.is_some() {
+							return Err(meta.error("Multiple output names provided for one field"));
+						}
+						let value = meta.value()?;
+						let lit: LitStr = value.parse()?;
+						this_output_name = Some(lit.value());
+						Ok(())
+					} else {
+						Err(meta.error("Unsupported output metadata. Supported syntax is #[output(name = \"...\")]"))
+					}
+				})?;
+			}
+		}
+
+		let this_output_name = this_output_name.ok_or_else(|| Error::new_spanned(attr, "Missing output name. Use #[output(name = \"...\")]"))?;
+		if output_name.is_some() {
+			return Err(Error::new_spanned(attr, "Multiple #[output(...)] attributes are not allowed on one field"));
+		}
+		output_name = Some(this_output_name);
+	}
+
+	Ok(output_name)
+}

node-graph/node-macro/src/lib.rs

@@ -131,13 +131,11 @@ mod destruct;
 #[proc_macro_derive(Destruct)]
 /// Derives the `Destruct` trait for structs and creates acessor node implementations.
 pub fn derive_destruct(item: TokenStream) -> TokenStream {
-	let s = syn::parse_macro_input!(item as syn::DeriveInput);
-	let parse_result = destruct::derive(s.ident, s.data).into();
-	let Ok(parsed_node) = parse_result else {
-		let e = parse_result.unwrap_err();
-		return syn::Error::new(e.span(), format!("Failed to parse node function: {e}")).to_compile_error().into();
-	};
-	parsed_node.into()
+	let input = syn::parse_macro_input!(item as syn::DeriveInput);
+	match destruct::derive(input) {
+		Ok(tokens) => tokens.into(),
+		Err(error) => syn::Error::new(error.span(), format!("Failed to derive Destruct: {error}")).to_compile_error().into(),
+	}
 }
 
 fn node_new_impl(attr: TokenStream, item: TokenStream) -> TokenStream {

node-graph/node-macro/src/parsing.rs

@@ -216,7 +216,7 @@ impl Parse for NodeFnAttributes {
 					skip_impl = true;
 				}
 				Meta::Path(path) if path.is_ident("deconstruct_output") => {
-					if skip_impl {
+					if deconstruct_output {
 						return Err(Error::new_spanned(path, "Multiple 'deconstruct_output' attributes are not allowed"));
 					}
 					deconstruct_output = true;