Fix Message Tree: Enforce Structure and Visibility

editor/src/messages/dialog/export_dialog/export_dialog_message.rs

@@ -4,9 +4,11 @@ use crate::messages::prelude::*;
 #[impl_message(Message, DialogMessage, ExportDialog)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ExportDialogMessage {
+	#[child]
 	FileType(FileType),
 	ScaleFactor(f64),
 	TransparentBackground(bool),
+	#[child]
 	ExportBounds(ExportBounds),
 
 	Submit,

editor/src/messages/frontend/utility_types.rs

@@ -29,6 +29,7 @@ pub enum MouseCursorIcon {
 	Rotate,
 }
 
+#[impl_message(Message, ExportDialogMessage, FileType)]
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq, serde::Serialize, serde::Deserialize, specta::Type)]
 pub enum FileType {
 	#[default]
@@ -47,6 +48,7 @@ impl FileType {
 	}
 }
 
+#[impl_message(Message, ExportDialogMessage, ExportBounds)]
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq, serde::Serialize, serde::Deserialize, specta::Type)]
 pub enum ExportBounds {
 	#[default]

editor/src/messages/message.rs

@@ -97,6 +97,17 @@ mod test {
 			}
 		}
 
+		// Print message field if any
+		if let Some(fields) = tree.fields() {
+			let len = fields.len();
+			for (i, field) in fields.iter().enumerate() {
+				let is_last_field = i == len - 1;
+				let branch = if is_last_field { "└── " } else { "├── " };
+
+				file.write_all(format!("{}{}{}\n", child_prefix, branch, field).as_bytes()).unwrap();
+			}
+		}
+
 		// Print handler field if any
 		if let Some(data) = tree.message_handler_fields() {
 			let len = data.fields().len();

editor/src/messages/prelude.rs

@@ -1,5 +1,5 @@
 // Root
-pub use crate::utility_traits::{ActionList, AsMessage, HierarchicalTree, MessageHandler, ToDiscriminant, TransitiveChild};
+pub use crate::utility_traits::{ActionList, AsMessage, ExtractField, HierarchicalTree, MessageHandler, ToDiscriminant, TransitiveChild};
 pub use crate::utility_types::{DebugMessageTree, MessageData};
 // Message, MessageData, MessageDiscriminant, MessageHandler
 pub use crate::messages::animation::{AnimationMessage, AnimationMessageDiscriminant, AnimationMessageHandler};

editor/src/messages/tool/transform_layer/transform_layer_message_handler.rs

@@ -67,6 +67,7 @@ pub struct TransformLayerMessageHandler {
 	ghost_outline: Vec<(Vec<ClickTargetType>, DAffine2)>,
 }
 
+#[message_handler_data]
 impl MessageHandler<TransformLayerMessage, TransformLayerMessageContext<'_>> for TransformLayerMessageHandler {
 	fn process_message(&mut self, message: TransformLayerMessage, responses: &mut VecDeque<Message>, context: TransformLayerMessageContext) {
 		let TransformLayerMessageContext {

editor/src/utility_traits.rs

@@ -60,3 +60,9 @@ pub trait HierarchicalTree {
 		""
 	}
 }
+
+pub trait ExtractField {
+	fn field_types() -> Vec<(String, usize)>;
+	fn path() -> &'static str;
+	fn print_field_types();
+}

editor/src/utility_types.rs

@@ -26,6 +26,7 @@ impl MessageData {
 #[derive(Debug)]
 pub struct DebugMessageTree {
 	name: String,
+	fields: Option<Vec<String>>,
 	variants: Option<Vec<DebugMessageTree>>,
 	message_handler: Option<MessageData>,
 	message_handler_data: Option<MessageData>,
@@ -36,13 +37,18 @@ impl DebugMessageTree {
 	pub fn new(name: &str) -> DebugMessageTree {
 		DebugMessageTree {
 			name: name.to_string(),
+			fields: None,
 			variants: None,
 			message_handler: None,
 			message_handler_data: None,
 			path: "",
 		}
 	}
 
+	pub fn add_fields(&mut self, fields: Vec<String>) {
+		self.fields = Some(fields);
+	}
+
 	pub fn set_path(&mut self, path: &'static str) {
 		self.path = path;
 	}
@@ -67,6 +73,10 @@ impl DebugMessageTree {
 		&self.name
 	}
 
+	pub fn fields(&self) -> Option<&Vec<String>> {
+		self.fields.as_ref()
+	}
+
 	pub fn path(&self) -> &'static str {
 		self.path
 	}

proc-macros/src/extract_fields.rs

@@ -34,20 +34,20 @@ pub fn derive_extract_field_impl(input: TokenStream) -> syn::Result<TokenStream>
 	let field_str = field_info.into_iter().map(|(name, ty)| (format!("{}: {}", name, ty)));
 
 	let res = quote! {
-		impl #impl_generics #struct_name #ty_generics #where_clause {
-			pub fn field_types() -> Vec<(String, usize)> {
+		impl #impl_generics ExtractField for #struct_name #ty_generics #where_clause {
+			fn field_types() -> Vec<(String, usize)> {
 				vec![
 					#((String::from(#field_str), #field_line)),*
 				]
 			}
 
-			pub fn print_field_types() {
+			fn print_field_types() {
 				for (field, line) in Self::field_types() {
 					println!("{} at line {}", field, line);
 				}
 			}
 
-			pub fn path() -> &'static str {
+			fn path() -> &'static str {
 				file!()
 			}
 		}

proc-macros/src/hierarchical_tree.rs

@@ -1,3 +1,4 @@
+use crate::helpers::clean_rust_type_syntax;
 use proc_macro2::{Span, TokenStream};
 use quote::{ToTokens, quote};
 use syn::{Data, DeriveInput, Fields, Type, parse2};
@@ -19,32 +20,48 @@ pub fn generate_hierarchical_tree(input: TokenStream) -> syn::Result<TokenStream
 			.iter()
 			.any(|attr| attr.path().get_ident().is_some_and(|ident| ident == "sub_discriminant" || ident == "child"));
 
-		if has_child {
-			if let Fields::Unnamed(fields) = &variant.fields {
+		return match &variant.fields {
+			Fields::Unit => quote! {
+				message_tree.add_variant(DebugMessageTree::new(stringify!(#variant_type)));
+			},
+			Fields::Unnamed(fields) => {
 				let field_type = &fields.unnamed.first().unwrap().ty;
+				if has_child {
+					quote! {
+						{
+							let mut variant_tree = DebugMessageTree::new(stringify!(#variant_type));
+							let field_name = stringify!(#field_type);
+							const message_string: &str = "Message";
+							if message_string == &field_name[field_name.len().saturating_sub(message_string.len())..] {
+								// The field is a Message type, recursively build its tree
+								let sub_tree = #field_type::build_message_tree();
+								variant_tree.add_variant(sub_tree);
+							} else {
+								variant_tree.add_fields(vec![format!("{field_name}")]);
+							}
+							message_tree.add_variant(variant_tree);
+						}
+					}
+				} else {
+					quote! {
+						message_tree.add_variant(DebugMessageTree::new(stringify!(#variant_type)));
+					}
+				}
+			}
+			Fields::Named(fields) => {
+				let names = fields.named.iter().map(|f| f.ident.as_ref().unwrap());
+				let ty = fields.named.iter().map(|f| clean_rust_type_syntax(f.ty.to_token_stream().to_string()));
 				quote! {
 					{
+						let mut field_names = Vec::new();
+						#(field_names.push(format!("{}: {}",stringify!(#names), #ty));)*
 						let mut variant_tree = DebugMessageTree::new(stringify!(#variant_type));
-						let field_name = stringify!(#field_type);
-						const message_string: &str = "Message";
-						if message_string == &field_name[field_name.len().saturating_sub(message_string.len())..] {
-							// The field is a Message type, recursively build its tree
-							let sub_tree = #field_type::build_message_tree();
-							variant_tree.add_variant(sub_tree);
-						}
+						variant_tree.add_fields(field_names);
 						message_tree.add_variant(variant_tree);
 					}
 				}
-			} else {
-				quote! {
-					message_tree.add_variant(DebugMessageTree::new(stringify!(#variant_type)));
-				}
-			}
-		} else {
-			quote! {
-				message_tree.add_variant(DebugMessageTree::new(stringify!(#variant_type)));
 			}
-		}
+		};
 	});
 
 	let res = quote! {
@@ -53,9 +70,8 @@ pub fn generate_hierarchical_tree(input: TokenStream) -> syn::Result<TokenStream
 				let mut message_tree = DebugMessageTree::new(stringify!(#input_type));
 				#(#build_message_tree)*
 				let message_handler_str = #input_type::message_handler_str();
-				if message_handler_str.fields().len() > 0 {
-					message_tree.add_message_handler_field(message_handler_str);
-				}
+
+				message_tree.add_message_handler_field(message_handler_str);
 
 				let message_handler_data_str = #input_type::message_handler_data_str();
 				if message_handler_data_str.fields().len() > 0 {

proc-macros/src/message_handler_data_attr.rs

@@ -43,10 +43,8 @@ pub fn message_handler_data_attr_impl(attr: TokenStream, input_item: TokenStream
 								quote! {
 									#input_item
 									impl #message_type {
-										pub fn message_handler_data_str() -> MessageData
-											{
+										pub fn message_handler_data_str() -> MessageData {
 											MessageData::new(format!("{}", stringify!(#type_name)), #type_name::field_types(), #type_name::path())
-
 										}
 										pub fn message_handler_str() -> MessageData {
 											MessageData::new(format!("{}", stringify!(#input_type)), #input_type::field_types(), #input_type::path())