Create from_borrowed and from_owned constructors for IceResult and BreadcrumbTreeElement.

In an effort to keep track of how often memory is getting heap allocated, I am implementing constructors for IceResult and BreadcrumbTreeElement. This should limit the places that I call Rc::new and allow me to place tracing code into it later to ensure all code paths doing heap allocation make sense.

src/renderer/breadcrumb_tree.rs

@@ -20,13 +20,25 @@ pub enum BreadcrumbTreeElement<'a> {
     Borrowed(&'a dyn IntoContextElement),
 }
 
+impl<'a> BreadcrumbTreeElement<'a> {
+    pub fn from_owned<I: 'a + IntoContextElement>(val: I) -> BreadcrumbTreeElement<'a> {
+        BreadcrumbTreeElement::Owned(Rc::new(val))
+    }
+
+    pub fn from_borrowed(val: &'a dyn IntoContextElement) -> BreadcrumbTreeElement<'a> {
+        BreadcrumbTreeElement::Borrowed(val)
+    }
+}
+
 impl<'a> From<&'a IceResult<'a>> for BreadcrumbTreeElement<'a> {
     fn from(inp: &'a IceResult<'a>) -> Self {
         match inp {
             IceResult::Owned(rc_ce) => {
-                BreadcrumbTreeElement::Borrowed(rc_ce.from_context_element())
+                BreadcrumbTreeElement::from_borrowed(rc_ce.from_context_element())
+            }
+            IceResult::Borrowed(ce) => {
+                BreadcrumbTreeElement::from_borrowed(ce.from_context_element())
             }
-            IceResult::Borrowed(ce) => BreadcrumbTreeElement::Borrowed(ce.from_context_element()),
         }
     }
 }
@@ -35,7 +47,9 @@ impl<'a> From<IceResult<'a>> for BreadcrumbTreeElement<'a> {
     fn from(inp: IceResult<'a>) -> Self {
         match inp {
             IceResult::Owned(rc_ce) => BreadcrumbTreeElement::Owned(rc_ce.into_rc_ice()),
-            IceResult::Borrowed(ce) => BreadcrumbTreeElement::Borrowed(ce.from_context_element()),
+            IceResult::Borrowed(ce) => {
+                BreadcrumbTreeElement::from_borrowed(ce.from_context_element())
+            }
         }
     }
 }

src/renderer/context_element.rs

@@ -116,7 +116,7 @@ impl<C: ContextElement> IntoContextElement for C {
         renderer: &DustRenderer,
         breadcrumbs: Option<&'a BreadcrumbTree<'a>>,
     ) -> Option<IceResult<'a>> {
-        Some(IceResult::Borrowed(self))
+        Some(IceResult::from_borrowed(self))
     }
 }
 
@@ -141,6 +141,14 @@ pub enum IceResult<'a> {
 }
 
 impl<'a> IceResult<'a> {
+    pub fn from_owned<C: 'static + ContextElement>(val: C) -> IceResult<'a> {
+        IceResult::Owned(Rc::new(val))
+    }
+
+    pub fn from_borrowed(val: &'a dyn ContextElement) -> IceResult<'a> {
+        IceResult::Borrowed(val)
+    }
+
     pub fn get_context_element_reference(&self) -> &dyn ContextElement {
         match self {
             IceResult::Owned(rc_ce) => rc_ce.as_ref(),
@@ -155,10 +163,9 @@ impl<'a> IntoContextElement for IceResult<'a> {
         renderer: &DustRenderer,
         breadcrumbs: Option<&'b BreadcrumbTree<'b>>,
     ) -> Option<IceResult<'b>> {
-        // Some(*self)
         match self {
-            IceResult::Owned(rc_ce) => Some(IceResult::Borrowed(rc_ce.as_ref())),
+            IceResult::Owned(rc_ce) => Some(IceResult::from_borrowed(rc_ce.as_ref())),
-            IceResult::Borrowed(ce) => Some(IceResult::Borrowed(*ce)),
+            IceResult::Borrowed(ce) => Some(IceResult::from_borrowed(*ce)),
         }
     }
 }

src/renderer/parameters_context.rs

@@ -45,14 +45,14 @@ impl<'a> ParametersContext<'a> {
                 let k = kvpair.key;
                 let v: Option<BreadcrumbTreeElement<'a>> = match &kvpair.value {
                     RValue::RVLiteral(owned_literal) => {
-                        Some(BreadcrumbTreeElement::Borrowed(&kvpair.value))
+                        Some(BreadcrumbTreeElement::from_borrowed(&kvpair.value))
                     }
                     RValue::RVPath(path) => kvpair
                         .value
                         .into_context_element(renderer, breadcrumbs)
                         .map(std::convert::From::from),
                     RValue::RVTemplate(template) => {
-                        Some(BreadcrumbTreeElement::Borrowed(&kvpair.value))
+                        Some(BreadcrumbTreeElement::from_borrowed(&kvpair.value))
                     }
                 };
                 v.map(|some_v| (k, some_v))
@@ -73,7 +73,7 @@ impl<'a> IntoContextElement for RValue<'a> {
         breadcrumbs: Option<&'b BreadcrumbTree<'b>>,
     ) -> Option<IceResult<'b>> {
         match self {
-            RValue::RVLiteral(owned_literal) => Some(IceResult::Borrowed(owned_literal)),
+            RValue::RVLiteral(owned_literal) => Some(IceResult::from_borrowed(owned_literal)),
             RValue::RVPath(path) => walk_path(breadcrumbs, &path.keys)
                 .map(|ice| ice.into_context_element(renderer, breadcrumbs))
                 .ok()
@@ -82,7 +82,7 @@ impl<'a> IntoContextElement for RValue<'a> {
                 .render_partial_name(template, breadcrumbs)
                 .map(|rendered| OwnedLiteral::LString(rendered))
                 .ok()
-                .map(|owned_literal| IceResult::Owned(Rc::new(owned_literal))),
+                .map(|owned_literal| IceResult::from_owned(owned_literal)),
         }
     }
 }

src/renderer/renderer.rs

@@ -49,7 +49,7 @@ impl<'a> DustRenderer<'a> {
         C: IntoContextElement,
     {
         let breadcrumbs =
-            context.map(|ctx| BreadcrumbTree::new(None, BreadcrumbTreeElement::Borrowed(ctx)));
+            context.map(|ctx| BreadcrumbTree::new(None, BreadcrumbTreeElement::from_borrowed(ctx)));
         self.render_template(name, breadcrumbs.as_ref(), None)
     }
 
@@ -231,10 +231,13 @@ impl<'a> DustRenderer<'a> {
                     }
                 });
         });
-        injected_context.map(|ctx| new_nodes.push(BreadcrumbTreeElement::Borrowed(ctx)));
+        injected_context.map(|ctx| new_nodes.push(BreadcrumbTreeElement::from_borrowed(ctx)));
-        new_context_element
+        new_context_element.map(|ctx| {
-            .map(|ctx| new_nodes.push(BreadcrumbTreeElement::Borrowed(ctx.from_context_element())));
+            new_nodes.push(BreadcrumbTreeElement::from_borrowed(
-        index_context.map(|ctx| new_nodes.push(BreadcrumbTreeElement::Borrowed(ctx)));
+                ctx.from_context_element(),
+            ))
+        });
+        index_context.map(|ctx| new_nodes.push(BreadcrumbTreeElement::from_borrowed(ctx)));
 
         Some((parent, new_nodes))
     }
@@ -284,7 +287,7 @@ impl<'a> DustRenderer<'a> {
                     parent = new_parent;
                     new_nodes.extend(passed_nodes.iter().map(|b| b.get_element().clone()));
                 }
-                _ => new_nodes.push(BreadcrumbTreeElement::Borrowed(ctx)),
+                _ => new_nodes.push(BreadcrumbTreeElement::from_borrowed(ctx)),
             }
         });
         explicit_context.as_ref().map(|path| {