Merge the breadcrumb tree trait and struct into just a struct.

src/renderer/breadcrumb_tree.rs

@@ -1,33 +1,32 @@
 use crate::renderer::context_element::IntoContextElement;
 use std::borrow::Borrow;
 
-pub trait BreadcrumbTree {
+pub struct BreadcrumbTree<'a> {
-    fn get_ice(&self) -> &dyn IntoContextElement;
+    parent: Option<&'a BreadcrumbTree<'a>>,
-
+    element: BreadcrumbTreeElement<'a>,
-    fn get_parent(&self) -> Option<&dyn BreadcrumbTree>;
 }
 
-pub struct BreadcrumbTreeNode<'a> {
+pub enum BreadcrumbTreeElement<'a> {
-    parent: Option<&'a dyn BreadcrumbTree>,
-    element: BreadcrumbTreeNodeElement<'a>,
-}
-
-pub enum BreadcrumbTreeNodeElement<'a> {
     Owned(Box<dyn IntoContextElement>),
     Borrowed(&'a dyn IntoContextElement),
 }
 
-impl<'a> BreadcrumbTreeNode<'a> {
+impl<'a> BreadcrumbTree<'a> {
-    pub fn new(
+    pub fn new(parent: Option<&'a BreadcrumbTree>, element: BreadcrumbTreeElement<'a>) -> Self {
-        parent: Option<&'a dyn BreadcrumbTree>,
+        BreadcrumbTree {
-        element: BreadcrumbTreeNodeElement<'a>,
-    ) -> Self {
-        BreadcrumbTreeNode {
             parent: parent,
             element: element,
         }
     }
 
+    pub fn get_ice(&self) -> &dyn IntoContextElement {
+        self.element.borrow()
+    }
+
+    pub fn get_parent(&self) -> Option<&BreadcrumbTree> {
+        self.parent
+    }
+
     pub fn ice_iter(&'a self) -> impl Iterator<Item = &dyn IntoContextElement> {
         self.breadcrumb_iter().map(|b| b.get_ice())
     }
@@ -37,27 +36,17 @@ impl<'a> BreadcrumbTreeNode<'a> {
     }
 }
 
-impl<'a> Borrow<dyn IntoContextElement + 'a> for BreadcrumbTreeNodeElement<'a> {
+impl<'a> Borrow<dyn IntoContextElement + 'a> for BreadcrumbTreeElement<'a> {
     fn borrow(&self) -> &(dyn IntoContextElement + 'a) {
         match self {
-            BreadcrumbTreeNodeElement::Owned(ice) => ice.as_ref(),
+            BreadcrumbTreeElement::Owned(ice) => ice.as_ref(),
-            BreadcrumbTreeNodeElement::Borrowed(ice) => *ice,
+            BreadcrumbTreeElement::Borrowed(ice) => *ice,
         }
     }
 }
 
-impl<'a> BreadcrumbTree for BreadcrumbTreeNode<'a> {
+impl<'a> IntoIterator for &'a BreadcrumbTree<'a> {
-    fn get_ice(&self) -> &dyn IntoContextElement {
+    type Item = &'a BreadcrumbTree<'a>;
-        self.element.borrow()
-    }
-
-    fn get_parent(&self) -> Option<&dyn BreadcrumbTree> {
-        self.parent
-    }
-}
-
-impl<'a> IntoIterator for &'a BreadcrumbTreeNode<'a> {
-    type Item = &'a dyn BreadcrumbTree;
     type IntoIter = BreadcrumbTreeIterator<'a>;
 
     fn into_iter(self) -> BreadcrumbTreeIterator<'a> {
@@ -65,10 +54,10 @@ impl<'a> IntoIterator for &'a BreadcrumbTreeNode<'a> {
     }
 }
 
-pub struct BreadcrumbTreeIterator<'a>(Option<&'a dyn BreadcrumbTree>);
+pub struct BreadcrumbTreeIterator<'a>(Option<&'a BreadcrumbTree<'a>>);
 
 impl<'a> Iterator for BreadcrumbTreeIterator<'a> {
-    type Item = &'a dyn BreadcrumbTree;
+    type Item = &'a BreadcrumbTree<'a>;
 
     fn next(&mut self) -> Option<Self::Item> {
         let ret = self.0;

src/renderer/tree_renderer.rs

@@ -2,8 +2,7 @@ use crate::parser::template;
 use crate::parser::Path;
 use crate::parser::Template;
 use crate::renderer::breadcrumb_tree::BreadcrumbTree;
-use crate::renderer::breadcrumb_tree::BreadcrumbTreeNode;
+use crate::renderer::breadcrumb_tree::BreadcrumbTreeElement;
-use crate::renderer::breadcrumb_tree::BreadcrumbTreeNodeElement;
 use crate::renderer::context_element::ContextElement;
 use crate::renderer::context_element::IntoContextElement;
 use crate::renderer::errors::CompileError;
@@ -56,15 +55,12 @@ impl<'a> DustRenderer<'a> {
     /// be empty) should be combined into a final BreadcrumbTreeNode
     fn new_breadcrumbs_section<'b>(
         &self,
-        maybe_breadcrumbs: Option<&'a BreadcrumbTreeNode>,
+        maybe_breadcrumbs: Option<&'a BreadcrumbTree>,
         index_context: Option<&'b dyn IntoContextElement>,
         injected_context: Option<&'b dyn IntoContextElement>,
         explicit_context: &Option<Path<'b>>,
         new_context_element: Option<&'b dyn ContextElement>,
-    ) -> Option<(
+    ) -> Option<(Option<&'b BreadcrumbTree>, Vec<BreadcrumbTreeElement<'b>>)> {
-        Option<&'b BreadcrumbTreeNode>,
-        Vec<BreadcrumbTreeNodeElement<'b>>,
-    )> {
         // If none of the additional contexts are present, return None
         // to signal that the original breadcrumbs should be used
         // rather than incurring a copy here.
@@ -95,13 +91,10 @@ impl<'a> DustRenderer<'a> {
         //             }
         //         });
         // });
-        injected_context.map(|ctx| new_nodes.push(BreadcrumbTreeNodeElement::Borrowed(ctx)));
+        injected_context.map(|ctx| new_nodes.push(BreadcrumbTreeElement::Borrowed(ctx)));
-        new_context_element.map(|ctx| {
+        new_context_element
-            new_nodes.push(BreadcrumbTreeNodeElement::Borrowed(
+            .map(|ctx| new_nodes.push(BreadcrumbTreeElement::Borrowed(ctx.from_context_element())));
-                ctx.from_context_element(),
+        index_context.map(|ctx| new_nodes.push(BreadcrumbTreeElement::Borrowed(ctx)));
-            ))
-        });
-        index_context.map(|ctx| new_nodes.push(BreadcrumbTreeNodeElement::Borrowed(ctx)));
 
         Some((parent, new_nodes))
     }

src/renderer/tree_walking.rs

@@ -1,5 +1,4 @@
 use crate::renderer::breadcrumb_tree::BreadcrumbTree;
-use crate::renderer::breadcrumb_tree::BreadcrumbTreeNode;
 use crate::renderer::context_element::IntoContextElement;
 use crate::renderer::WalkError;
 use std::borrow::Borrow;
@@ -39,8 +38,8 @@ where
 }
 
 fn get_first_non_pseudo_element<'a>(
-    breadcrumbs: &'a BreadcrumbTreeNode,
+    breadcrumbs: &'a BreadcrumbTree,
-) -> Option<&'a dyn BreadcrumbTree> {
+) -> Option<&'a BreadcrumbTree<'a>> {
     breadcrumbs
         .breadcrumb_iter()
         .filter(|b| b.get_ice().is_pseudo_element())
@@ -48,7 +47,7 @@ fn get_first_non_pseudo_element<'a>(
 }
 
 pub fn walk_path<'a, P>(
-    maybe_breadcrumbs: Option<&'a BreadcrumbTreeNode>,
+    maybe_breadcrumbs: Option<&'a BreadcrumbTree>,
     path: &Vec<P>,
 ) -> Result<&'a dyn IntoContextElement, WalkError>
 where