Fallible layout

2 files changed, 28 insertions, 16 deletions

diff --git a/src/eval/show.rs b/src/eval/show.rs
index 6157485d..a6a48e6f 100644
--- a/src/eval/show.rs
+++ b/src/eval/show.rs
@@ -4,12 +4,14 @@ use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 
 use super::{StyleChain, Template};
+use crate::diag::TypResult;
 use crate::util::Prehashed;
+use crate::Vm;
 
 /// A node that can be realized given some styles.
 pub trait Show {
     /// Realize the template in the given styles.
-    fn show(&self, styles: StyleChain) -> Template;
+    fn show(&self, vm: &mut Vm, styles: StyleChain) -> TypResult<Template>;
 
     /// Convert to a packed show node.
     fn pack(self) -> ShowNode
@@ -40,8 +42,8 @@ impl ShowNode {
 }
 
 impl Show for ShowNode {
-    fn show(&self, styles: StyleChain) -> Template {
-        self.0.show(styles)
+    fn show(&self, vm: &mut Vm, styles: StyleChain) -> TypResult<Template> {
+        self.0.show(vm, styles)
     }
 
     fn pack(self) -> ShowNode {
diff --git a/src/eval/template.rs b/src/eval/template.rs
index 2cd6797a..b1fe07fe 100644
--- a/src/eval/template.rs
+++ b/src/eval/template.rs
@@ -165,20 +165,22 @@ impl Template {
     }
 
     /// Layout this template into a collection of pages.
-    pub fn layout(&self, vm: &mut Vm) -> Vec<Arc<Frame>> {
+    pub fn layout(&self, vm: &mut Vm) -> TypResult<Vec<Arc<Frame>>> {
         let style_arena = Arena::new();
         let template_arena = Arena::new();
 
         let mut builder = Builder::new(&style_arena, &template_arena, true);
         let chain = StyleChain::new(vm.styles);
-        builder.process(self, chain);
+        builder.process(self, vm, chain)?;
         builder.finish_page(true, false, chain);
 
+        let mut frames = vec![];
         let (pages, shared) = builder.pages.unwrap().finish();
-        pages
-            .iter()
-            .flat_map(|(page, map)| page.layout(vm, map.chain(&shared)))
-            .collect()
+        for (page, map) in pages.iter() {
+            frames.extend(page.layout(vm, map.chain(&shared))?);
+        }
+
+        Ok(frames)
     }
 }
 
@@ -269,12 +271,12 @@ impl Layout for Template {
         vm: &mut Vm,
         regions: &Regions,
         styles: StyleChain,
-    ) -> Vec<Constrained<Arc<Frame>>> {
+    ) -> TypResult<Vec<Constrained<Arc<Frame>>>> {
         let style_arena = Arena::new();
         let template_arena = Arena::new();
 
         let mut builder = Builder::new(&style_arena, &template_arena, false);
-        builder.process(self, styles);
+        builder.process(self, vm, styles)?;
         builder.finish_par(styles);
 
         let (flow, shared) = builder.flow.finish();
@@ -323,7 +325,12 @@ impl<'a> Builder<'a> {
     }
 
     /// Process a template.
-    fn process(&mut self, template: &'a Template, styles: StyleChain<'a>) {
+    fn process(
+        &mut self,
+        template: &'a Template,
+        vm: &mut Vm,
+        styles: StyleChain<'a>,
+    ) -> TypResult<()> {
         match template {
             Template::Space => {
                 self.par.weak(ParChild::Text(' '.into()), 0, styles);
@@ -382,8 +389,9 @@ impl<'a> Builder<'a> {
                 }
             }
             Template::Show(node) => {
-                let template = self.template_arena.alloc(node.show(styles));
-                self.process(template, styles.unscoped(node.id()));
+                let template = node.show(vm, styles)?;
+                let stored = self.template_arena.alloc(template);
+                self.process(stored, vm, styles.unscoped(node.id()))?;
             }
             Template::Styled(styled) => {
                 let (sub, map) = styled.as_ref();
@@ -397,7 +405,7 @@ impl<'a> Builder<'a> {
                     None => {}
                 }
 
-                self.process(sub, styles);
+                self.process(sub, vm, styles)?;
 
                 match interruption {
                     Some(Interruption::Page) => self.finish_page(true, false, styles),
@@ -407,10 +415,12 @@ impl<'a> Builder<'a> {
             }
             Template::Sequence(seq) => {
                 for sub in seq.iter() {
-                    self.process(sub, styles);
+                    self.process(sub, vm, styles)?;
                 }
             }
         }
+
+        Ok(())
     }
 
     /// Finish the currently built paragraph.