feat: change the HierarchicalTree from String to DebugMessageTree struct

editor/src/messages/debug/mod.rs

@@ -3,6 +3,8 @@ mod debug_message_handler;
 
 pub mod utility_types;
 
+pub use utility_types::DebugMessageTree;
+
 #[doc(inline)]
 pub use debug_message::{DebugMessage, DebugMessageDiscriminant};
 #[doc(inline)]

editor/src/messages/debug/utility_types.rs

@@ -5,3 +5,33 @@ pub enum MessageLoggingVerbosity {
 	Names,
 	Contents,
 }
+
+pub struct DebugMessageTree {
+	name: String,
+	variants: Option<Vec<DebugMessageTree>>,
+}
+
+impl DebugMessageTree {
+	pub fn new(name: &str) -> DebugMessageTree {
+		DebugMessageTree {
+			name: name.to_string(),
+			variants: None,
+		}
+	}
+
+	pub fn add_variant(&mut self, variant: DebugMessageTree) {
+		if let Some(variants) = &mut self.variants {
+			variants.push(variant);
+		} else {
+			self.variants = Some(vec![variant]);
+		}
+	}
+
+	pub fn name(&self) -> &str {
+		&self.name
+	}
+
+	pub fn variants(&self) -> Option<&Vec<DebugMessageTree>> {
+		self.variants.as_ref()
+	}
+}

editor/src/messages/message.rs

@@ -45,3 +45,38 @@ impl specta::Type for MessageDiscriminant {
 		specta::DataType::Any
 	}
 }
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	#[test]
+	fn generate_message_tree() {
+		let res = Message::build_message_tree();
+		println!("{}", res.name());
+		if let Some(variants) = res.variants() {
+			for (i, variant) in variants.iter().enumerate() {
+				let is_last = i == variants.len() - 1;
+				print_tree_node(variant, "", is_last);
+			}
+		}
+	}
+
+	fn print_tree_node(tree: &DebugMessageTree, prefix: &str, is_last: bool) {
+		// Print the current node
+		let branch = if is_last { "└── " } else { "├── " };
+		println!("{}{}{}", prefix, branch, tree.name());
+
+		// Prepare prefix for children
+		let child_prefix = if is_last { format!("{}    ", prefix) } else { format!("{}│   ", prefix) };
+
+		// Print children if any
+		if let Some(variants) = tree.variants() {
+			let len = variants.len();
+			for (i, variant) in variants.iter().enumerate() {
+				let is_last_child = i == len - 1;
+				print_tree_node(variant, &child_prefix, is_last_child);
+			}
+		}
+	}
+}

editor/src/messages/prelude.rs

@@ -1,10 +1,10 @@
 // Root
-pub use crate::utility_traits::{ActionList, AsMessage, MessageHandler, ToDiscriminant, TransitiveChild, HierarchicalTree};
+pub use crate::utility_traits::{ActionList, AsMessage, HierarchicalTree, MessageHandler, ToDiscriminant, TransitiveChild};
 
 // Message, MessageData, MessageDiscriminant, MessageHandler
 pub use crate::messages::animation::{AnimationMessage, AnimationMessageDiscriminant, AnimationMessageHandler};
 pub use crate::messages::broadcast::{BroadcastMessage, BroadcastMessageDiscriminant, BroadcastMessageHandler};
-pub use crate::messages::debug::{DebugMessage, DebugMessageDiscriminant, DebugMessageHandler};
+pub use crate::messages::debug::{DebugMessage, DebugMessageDiscriminant, DebugMessageHandler, DebugMessageTree};
 pub use crate::messages::dialog::export_dialog::{ExportDialogMessage, ExportDialogMessageData, ExportDialogMessageDiscriminant, ExportDialogMessageHandler};
 pub use crate::messages::dialog::new_document_dialog::{NewDocumentDialogMessage, NewDocumentDialogMessageDiscriminant, NewDocumentDialogMessageHandler};
 pub use crate::messages::dialog::preferences_dialog::{PreferencesDialogMessage, PreferencesDialogMessageData, PreferencesDialogMessageDiscriminant, PreferencesDialogMessageHandler};

editor/src/utility_traits.rs

@@ -47,6 +47,5 @@ pub trait Hint {
 }
 
 pub trait HierarchicalTree {
-	fn generate_hierarchical_tree() -> Vec<String>;
-	fn generate_enum_variants(depth: usize, tree: &mut Vec<String>);
+	fn build_message_tree() -> DebugMessageTree;
 }

proc-macros/src/hierarchical_tree.rs

@@ -11,10 +11,8 @@ pub fn generate_hierarchical_tree(input: TokenStream) -> syn::Result<TokenStream
 		_ => return Err(syn::Error::new(Span::call_site(), "Tried to derive HierarchicalTree for non-enum")),
 	};
 
-	let variant_prints = data.variants.iter().enumerate().map(|(index, variant)| {
+	let build_message_tree = data.variants.iter().map(|variant| {
 		let variant_type = &variant.ident;
-		let is_last = index == data.variants.len() - 1;
-		let tree_symbol = if is_last { "└──" } else { "├──" };
 
 		let has_child = variant
 			.attrs
@@ -25,32 +23,35 @@ pub fn generate_hierarchical_tree(input: TokenStream) -> syn::Result<TokenStream
 			if let Fields::Unnamed(fields) = &variant.fields {
 				let field_type = &fields.unnamed.first().unwrap().ty;
 				quote! {
-					tree.push(format!("{}{}{}", "│   ".repeat(depth), #tree_symbol, stringify!(#variant_type)));
-					<#field_type>::generate_enum_variants(depth + 1, tree);
+					{
+						let mut variant_tree = DebugMessageTree::new(stringify!(#variant_type));
+						let field_name = stringify!(#field_type);
+						if "Message" == &field_name[field_name.len().saturating_sub(7)..] {
+							// The field is a Message type, recursively build its tree
+							let sub_tree = #field_type::build_message_tree();
+							variant_tree.add_variant(sub_tree);
+						}
+						message_tree.add_variant(variant_tree);
+					}
 				}
 			} else {
 				quote! {
-					tree.push(format!("{}{}{}", "│   ".repeat(depth), #tree_symbol, stringify!(#variant_type)));
+					message_tree.add_variant(DebugMessageTree::new(stringify!(#variant_type)));
 				}
 			}
 		} else {
 			quote! {
-				tree.push(format!("{}{}{}", "│   ".repeat(depth), #tree_symbol, stringify!(#variant_type)));
+				message_tree.add_variant(DebugMessageTree::new(stringify!(#variant_type)));
 			}
 		}
 	});
 
 	let res = quote! {
 		impl HierarchicalTree for #input_type {
-			fn generate_hierarchical_tree() -> Vec<String> {
-				let mut hierarchical_tree = Vec::new();
-				hierarchical_tree.push(format!("{}", stringify!(#input_type)));
-				Self::generate_enum_variants(0, &mut hierarchical_tree);
-				hierarchical_tree
-			}
-
-			fn generate_enum_variants(depth: usize, tree: &mut Vec<String>) {
-				#(#variant_prints)*
+			fn build_message_tree() -> DebugMessageTree {
+				let mut message_tree = DebugMessageTree::new(stringify!(#input_type));
+				#(#build_message_tree)*
+				message_tree
 			}
 		}
 	};