test(deep_causality_ast): minor lints and optimizations.

Signed-off-by: Marvin Hansen <[email protected]>

Author: marvin-hansen

deep_causality_ast/Cargo.toml

@@ -7,7 +7,7 @@ license.workspace = true
 
 repository = "https://github.com/deepcausality/deep_causality.rs"
 authors = ["Marvin Hansen <[email protected]>", ]
-description = "AST data structure for for deep_causality crate."
+description = "AST data structure for deep_causality crate."
 documentation = "https://docs.rs/deep_causality"
 categories = ["data-structures", "science"]
 keywords = ["data-structures", "ast"]

deep_causality_ast/src/const_tree/accessors.rs

@@ -78,7 +78,7 @@ impl<T> ConstTree<T> {
         let mut max_depth = 0;
         let mut queue = VecDeque::new();
 
-        // Always start with the root node at depth 1.
+        // Start with the root node at depth 1.
         queue.push_back((self, 1));
 
         while let Some((current_node, current_depth)) = queue.pop_front() {

deep_causality_ast/src/const_tree/map.rs

@@ -25,15 +25,19 @@ impl<T: Clone> ConstTree<ConstTree<T>> {
     /// assert_eq!(*joined.children()[0].value(), 2);
     /// ```
     pub fn join(self) -> ConstTree<T> {
-        // The root of the outer tree has a value which is the inner tree.
-        let inner_tree = self.value().clone();
+        // Consume the outer node when possible to avoid unnecessary clones.
+        let outer_node = Arc::try_unwrap(self.node).unwrap_or_else(|arc| (*arc).clone());
 
-        // The new children are the children of the inner tree,
-        // plus the result of recursively joining the children of the outer tree.
+        // Take the inner tree (value of the outer root).
+        let inner_tree = outer_node.value;
+
+        // Start with inner_tree's existing children.
         let mut new_children = inner_tree.children().to_vec();
-        let joined_outer_children = self.children().iter().map(|c| c.clone().join());
-        new_children.extend(joined_outer_children);
 
+        // Recursively join each outer child into a flat ConstTree<T>.
+        new_children.extend(outer_node.children.into_iter().map(|c| c.join()));
+
+        // Build the resulting tree using the inner root value.
         ConstTree::with_children(inner_tree.value().clone(), new_children)
     }
 }

deep_causality_ast/tests/const_tree/const_tree_tests.rs

@@ -1,3 +1,8 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
 #![allow(dead_code)]
 #![allow(unused_imports)]
 
@@ -283,6 +288,16 @@ fn test_into_map() {
     assert_eq!(*tree_clone.children()[0].value(), 20);
 }
 
+#[test]
+fn test_consuming_iterator_ok_branch() {
+    let tree = ConstTree::with_children(1, vec![ConstTree::new(2), ConstTree::new(3)]);
+
+    // Call into_iter on the original tree, ensuring no other clones exist.
+    // This should trigger the Ok branch of Arc::try_unwrap for the root node.
+    let values: Vec<_> = tree.into_iter().collect();
+    assert_eq!(values, vec![1, 2, 3]);
+}
+
 #[test]
 fn test_consuming_iterator_shared_arc() {
     let tree = ConstTree::with_children(1, vec![ConstTree::new(2), ConstTree::new(3)]);