Add Value type and replace dyn-nodes with call-exprs 🏗

- In addition to syntax trees there are now `Value`s, which syntax trees can be evaluated into (e.g. the tree is `5+5` and the value is `10`)
- Parsing is completely pure, function calls are not parsed into nodes, but into simple call expressions, which are resolved later
- Functions aren't dynamic nodes anymore, but simply functions which receive their arguments as a table and the layouting context
- Functions may return any `Value`
- Layouting is powered by functions which return the new `Commands` value, which informs the layouting engine what to do
- When a function returns a non-`Commands` value, the layouter simply dumps the value into the document in monospace

1 files changed, 38 insertions, 56 deletions

diff --git a/src/library/align.rs b/src/library/align.rs
index b4cfd2e2..c716faef 100644
--- a/src/library/align.rs
+++ b/src/library/align.rs
@@ -10,67 +10,49 @@ use super::*;
 /// - `vertical`: Any of `top`, `bottom` or `center`.
 ///
 /// There may not be two alignment specifications for the same axis.
-pub fn align(call: FuncCall, _: &ParseState) -> Pass<SyntaxNode> {
+pub async fn align(mut args: TableValue, mut ctx: LayoutContext<'_>) -> Pass<Value> {
     let mut f = Feedback::new();
-    let mut args = call.args;
-    let node = AlignNode {
-        content: args.take::<SyntaxTree>(),
-        aligns: args.take_all_num_vals::<Spanned<SpecAlign>>().collect(),
-        h: args.take_with_key::<_, Spanned<SpecAlign>>("horizontal", &mut f),
-        v: args.take_with_key::<_, Spanned<SpecAlign>>("vertical", &mut f),
-    };
-    args.unexpected(&mut f);
-    Pass::node(node, f)
-}
-
-#[derive(Debug, Clone, PartialEq)]
-struct AlignNode {
-    content: Option<SyntaxTree>,
-    aligns: SpanVec<SpecAlign>,
-    h: Option<Spanned<SpecAlign>>,
-    v: Option<Spanned<SpecAlign>>,
-}
 
-#[async_trait(?Send)]
-impl Layout for AlignNode {
-    async fn layout<'a>(&'a self, mut ctx: LayoutContext<'_>) -> Pass<Commands<'a>> {
-        let mut f = Feedback::new();
+    let content = args.take::<SyntaxTree>();
+    let aligns: Vec<_> = args.take_all_num_vals::<Spanned<SpecAlign>>().collect();
+    let h = args.take_with_key::<_, Spanned<SpecAlign>>("horizontal", &mut f);
+    let v = args.take_with_key::<_, Spanned<SpecAlign>>("vertical", &mut f);
+    args.unexpected(&mut f);
 
-        ctx.base = ctx.spaces[0].size;
+    ctx.base = ctx.spaces[0].size;
 
-        let axes = ctx.axes;
-        let all = self.aligns.iter()
-            .map(|align| {
-                let spec = align.v.axis().unwrap_or(axes.primary.axis());
-                (spec, align)
-            })
-            .chain(self.h.iter().map(|align| (Horizontal, align)))
-            .chain(self.v.iter().map(|align| (Vertical, align)));
+    let axes = ctx.axes;
+    let all = aligns.iter()
+        .map(|align| {
+            let spec = align.v.axis().unwrap_or(axes.primary.axis());
+            (spec, align)
+        })
+        .chain(h.iter().map(|align| (Horizontal, align)))
+        .chain(v.iter().map(|align| (Vertical, align)));
 
-        let mut had = [false; 2];
-        for (axis, align) in all {
-            if align.v.axis().map(|a| a != axis).unwrap_or(false) {
-                error!(
-                    @f, align.span,
-                    "invalid alignment {} for {} axis", align.v, axis,
-                );
-            } else if had[axis as usize] {
-                error!(@f, align.span, "duplicate alignment for {} axis", axis);
-            } else {
-                had[axis as usize] = true;
-                let gen_axis = axis.to_generic(ctx.axes);
-                let gen_align = align.v.to_generic(ctx.axes);
-                *ctx.align.get_mut(gen_axis) = gen_align;
-            }
+    let mut had = [false; 2];
+    for (axis, align) in all {
+        if align.v.axis().map(|a| a != axis).unwrap_or(false) {
+            error!(
+                @f, align.span,
+                "invalid alignment {} for {} axis", align.v, axis,
+            );
+        } else if had[axis as usize] {
+            error!(@f, align.span, "duplicate alignment for {} axis", axis);
+        } else {
+            had[axis as usize] = true;
+            let gen_axis = axis.to_generic(ctx.axes);
+            let gen_align = align.v.to_generic(ctx.axes);
+            *ctx.align.get_mut(gen_axis) = gen_align;
         }
-
-        Pass::new(match &self.content {
-            Some(tree) => {
-                let layouted = layout(tree, ctx).await;
-                f.extend(layouted.feedback);
-                vec![AddMultiple(layouted.output)]
-            }
-            None => vec![SetAlignment(ctx.align)],
-        }, f)
     }
+
+    Pass::commands(match content {
+        Some(tree) => {
+            let layouted = layout(&tree, ctx).await;
+            f.extend(layouted.feedback);
+            vec![AddMultiple(layouted.output)]
+        }
+        None => vec![SetAlignment(ctx.align)],
+    }, f)
 }