Running into issue where I need to know the type to create new tree node elements.

src/renderer/breadcrumb_tree.rs

@@ -12,7 +12,7 @@ pub struct BreadcrumbTreeNode<'a, C: IntoContextElement> {
     element: BreadcrumbTreeNodeElement<'a, C>,
 }
 
-enum BreadcrumbTreeNodeElement<'a, C: IntoContextElement> {
+pub enum BreadcrumbTreeNodeElement<'a, C: IntoContextElement> {
     Owned(C),
     Borrowed(&'a C),
 }

src/renderer/tree_renderer.rs

@@ -1,5 +1,11 @@
 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::BreadcrumbTreeNodeElement;
+use crate::renderer::context_element::ContextElement;
+use crate::renderer::context_element::IntoContextElement;
 use crate::renderer::errors::CompileError;
 use std::collections::HashMap;
 
@@ -32,4 +38,50 @@ impl<'a> DustRenderer<'a> {
             templates: HashMap::new(),
         }
     }
+
+    pub fn load_source(&mut self, template: &'a CompiledTemplate) {
+        self.templates
+            .insert(template.name.clone(), &template.template);
+    }
+
+    fn new_breadcrumbs_section<'b, B>(
+        &self,
+        maybe_breadcrumbs: Option<&'a BreadcrumbTreeNode<B>>,
+        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<&'a BreadcrumbTreeNode<B>>
+    where
+        B: IntoContextElement,
+    {
+        // If there is no new content, return the original breadcrumbs
+        match (
+            index_context,
+            injected_context,
+            explicit_context,
+            new_context_element,
+        ) {
+            (None, None, None, None) => return maybe_breadcrumbs,
+            _ => (),
+        }
+
+        // If there is an explicit context, then drop all the current
+        // context
+        let mut new_stack = match explicit_context {
+            Some(_) => None,
+            None => maybe_breadcrumbs,
+        };
+
+        // TODO: Explicit context
+        injected_context.map(|ctx| {
+            new_stack = Some(BreadcrumbTreeNode {
+                parent: new_stack.map(|b| b as _),
+                element: BreadcrumbTreeNodeElement::Borrowed(ctx),
+            });
+            // TODO
+        });
+
+        None
+    }
 }