2 files changed, 19 insertions, 18 deletions

diff --git a/src/exec/context.rs b/src/exec/context.rs
index 4764a808..04c0169d 100644
--- a/src/exec/context.rs
+++ b/src/exec/context.rs
@@ -4,10 +4,10 @@ use std::rc::Rc;
 use super::{Exec, ExecWithMap, FontFamily, State};
 use crate::diag::{Diag, DiagSet, Pass};
 use crate::eco::EcoString;
-use crate::eval::{ExprMap, TemplateValue};
+use crate::eval::{ExprMap, Template};
 use crate::geom::{Align, Dir, Gen, GenAxis, Length, Linear, Sides, Size};
 use crate::layout::{
-    AnyNode, LayoutTree, PadNode, PageRun, ParChild, ParNode, StackChild, StackNode,
+    LayoutNode, LayoutTree, PadNode, PageRun, ParChild, ParNode, StackChild, StackNode,
 };
 use crate::syntax::{Span, SyntaxTree};
 
@@ -53,7 +53,7 @@ impl ExecContext {
     }
 
     /// Execute a template and return the result as a stack node.
-    pub fn exec_template_stack(&mut self, template: &TemplateValue) -> StackNode {
+    pub fn exec_template_stack(&mut self, template: &Template) -> StackNode {
         self.exec_stack(|ctx| template.exec(ctx))
     }
 
@@ -88,13 +88,13 @@ impl ExecContext {
     }
 
     /// Push any node into the active paragraph.
-    pub fn push_into_par(&mut self, node: impl Into<AnyNode>) {
+    pub fn push_into_par(&mut self, node: impl Into<LayoutNode>) {
         let align = self.state.aligns.cross;
         self.stack.par.push(ParChild::Any(node.into(), align));
     }
 
     /// Push any node into the active stack.
-    pub fn push_into_stack(&mut self, node: impl Into<AnyNode>) {
+    pub fn push_into_stack(&mut self, node: impl Into<LayoutNode>) {
         self.parbreak();
         let aligns = self.state.aligns;
         self.stack.push(StackChild::Any(node.into(), aligns));
diff --git a/src/exec/mod.rs b/src/exec/mod.rs
index 2a145fbc..752bdba5 100644
--- a/src/exec/mod.rs
+++ b/src/exec/mod.rs
@@ -10,15 +10,15 @@ use std::fmt::Write;
 use std::rc::Rc;
 
 use crate::diag::Pass;
-use crate::eval::{ExprMap, TemplateFunc, TemplateNode, TemplateValue, Value};
+use crate::eco::EcoString;
+use crate::eval::{ExprMap, Template, TemplateFunc, TemplateNode, TemplateTree, Value};
 use crate::geom::{Dir, Gen};
 use crate::layout::{LayoutTree, StackChild, StackNode};
 use crate::pretty::pretty;
-use crate::eco::EcoString;
 use crate::syntax::*;
 
 /// Execute a template to produce a layout tree.
-pub fn exec(template: &TemplateValue, state: State) -> Pass<LayoutTree> {
+pub fn exec(template: &Template, state: State) -> Pass<LayoutTree> {
     let mut ctx = ExecContext::new(state);
     template.exec(&mut ctx);
     ctx.finish()
@@ -50,7 +50,7 @@ impl ExecWithMap for SyntaxTree {
     }
 }
 
-impl ExecWithMap for Node {
+impl ExecWithMap for SyntaxNode {
     fn exec_with_map(&self, ctx: &mut ExecContext, map: &ExprMap) {
         match self {
             Self::Text(text) => ctx.push_text(text),
@@ -117,12 +117,7 @@ impl ExecWithMap for EnumItem {
     }
 }
 
-fn exec_item(
-    ctx: &mut ExecContext,
-    label: EcoString,
-    body: &SyntaxTree,
-    map: &ExprMap,
-) {
+fn exec_item(ctx: &mut ExecContext, label: EcoString, body: &SyntaxTree, map: &ExprMap) {
     let label = ctx.exec_stack(|ctx| ctx.push_text(label));
     let body = ctx.exec_tree_stack(body, map);
     let stack = StackNode {
@@ -159,7 +154,7 @@ impl Exec for Value {
     }
 }
 
-impl Exec for TemplateValue {
+impl Exec for Template {
     fn exec(&self, ctx: &mut ExecContext) {
         for node in self.iter() {
             node.exec(ctx);
@@ -170,13 +165,19 @@ impl Exec for TemplateValue {
 impl Exec for TemplateNode {
     fn exec(&self, ctx: &mut ExecContext) {
         match self {
-            Self::Tree { tree, map } => tree.exec_with_map(ctx, &map),
-            Self::Str(v) => ctx.push_text(v),
+            Self::Tree(v) => v.exec(ctx),
             Self::Func(v) => v.exec(ctx),
+            Self::Str(v) => ctx.push_text(v),
         }
     }
 }
 
+impl Exec for TemplateTree {
+    fn exec(&self, ctx: &mut ExecContext) {
+        self.tree.exec_with_map(ctx, &self.map)
+    }
+}
+
 impl Exec for TemplateFunc {
     fn exec(&self, ctx: &mut ExecContext) {
         let snapshot = ctx.state.clone();