Inline literal enum into expression enum 🔀

1 files changed, 34 insertions, 48 deletions

diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index 1c6e3d51..68a97b43 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -75,7 +75,6 @@ impl Eval for Spanned<&Node> {
                 let node = ctx.make_text_node(text.clone());
                 ctx.push(node);
             }
-
             Node::Space => {
                 let em = ctx.state.font.font_size();
                 ctx.push(NodeSpacing {
@@ -85,13 +84,10 @@ impl Eval for Spanned<&Node> {
             }
             Node::Linebreak => ctx.apply_linebreak(),
             Node::Parbreak => ctx.apply_parbreak(),
-
             Node::Strong => ctx.state.font.strong ^= true,
             Node::Emph => ctx.state.font.emph ^= true,
-
             Node::Heading(heading) => heading.with_span(self.span).eval(ctx),
             Node::Raw(raw) => raw.with_span(self.span).eval(ctx),
-
             Node::Expr(expr) => {
                 let value = expr.with_span(self.span).eval(ctx);
                 value.eval(ctx)
@@ -153,60 +149,31 @@ impl Eval for Spanned<&Expr> {
 
     fn eval(self, ctx: &mut EvalContext) -> Self::Output {
         match self.v {
-            Expr::Lit(v) => v.with_span(self.span).eval(ctx),
-            Expr::Call(v) => v.with_span(self.span).eval(ctx),
-            Expr::Unary(v) => v.with_span(self.span).eval(ctx),
-            Expr::Binary(v) => v.with_span(self.span).eval(ctx),
-            Expr::Array(v) => Value::Array(v.with_span(self.span).eval(ctx)),
-            Expr::Dict(v) => Value::Dict(v.with_span(self.span).eval(ctx)),
-            Expr::Content(v) => Value::Content(v.clone()),
-        }
-    }
-}
-
-impl Eval for Spanned<&Lit> {
-    type Output = Value;
-
-    fn eval(self, ctx: &mut EvalContext) -> Self::Output {
-        match *self.v {
-            Lit::Ident(ref v) => match ctx.state.scope.get(&v) {
+            Expr::None => Value::None,
+            Expr::Ident(v) => match ctx.state.scope.get(v) {
                 Some(value) => value.clone(),
                 None => {
                     ctx.diag(error!(self.span, "unknown variable"));
                     Value::Error
                 }
             },
-            Lit::None => Value::None,
-            Lit::Bool(v) => Value::Bool(v),
-            Lit::Int(v) => Value::Int(v),
-            Lit::Float(v) => Value::Float(v),
-            Lit::Length(v, unit) => Value::Length(Length::with_unit(v, unit)),
-            Lit::Percent(v) => Value::Relative(Relative::new(v / 100.0)),
-            Lit::Color(v) => Value::Color(Color::Rgba(v)),
-            Lit::Str(ref v) => Value::Str(v.clone()),
+            Expr::Bool(v) => Value::Bool(*v),
+            Expr::Int(v) => Value::Int(*v),
+            Expr::Float(v) => Value::Float(*v),
+            Expr::Length(v, unit) => Value::Length(Length::with_unit(*v, *unit)),
+            Expr::Percent(v) => Value::Relative(Relative::new(v / 100.0)),
+            Expr::Color(v) => Value::Color(Color::Rgba(*v)),
+            Expr::Str(v) => Value::Str(v.clone()),
+            Expr::Call(v) => v.with_span(self.span).eval(ctx),
+            Expr::Unary(v) => v.with_span(self.span).eval(ctx),
+            Expr::Binary(v) => v.with_span(self.span).eval(ctx),
+            Expr::Array(v) => Value::Array(v.with_span(self.span).eval(ctx)),
+            Expr::Dict(v) => Value::Dict(v.with_span(self.span).eval(ctx)),
+            Expr::Content(v) => Value::Content(v.clone()),
         }
     }
 }
 
-impl Eval for Spanned<&ExprArray> {
-    type Output = ValueArray;
-
-    fn eval(self, ctx: &mut EvalContext) -> Self::Output {
-        self.v.iter().map(|expr| expr.as_ref().eval(ctx)).collect()
-    }
-}
-
-impl Eval for Spanned<&ExprDict> {
-    type Output = ValueDict;
-
-    fn eval(self, ctx: &mut EvalContext) -> Self::Output {
-        self.v
-            .iter()
-            .map(|Named { name, expr }| (name.v.0.clone(), expr.as_ref().eval(ctx)))
-            .collect()
-    }
-}
-
 impl Eval for Spanned<&ExprUnary> {
     type Output = Value;
 
@@ -245,6 +212,25 @@ impl Eval for Spanned<&ExprBinary> {
     }
 }
 
+impl Eval for Spanned<&ExprArray> {
+    type Output = ValueArray;
+
+    fn eval(self, ctx: &mut EvalContext) -> Self::Output {
+        self.v.iter().map(|expr| expr.as_ref().eval(ctx)).collect()
+    }
+}
+
+impl Eval for Spanned<&ExprDict> {
+    type Output = ValueDict;
+
+    fn eval(self, ctx: &mut EvalContext) -> Self::Output {
+        self.v
+            .iter()
+            .map(|Named { name, expr }| (name.v.0.clone(), expr.as_ref().eval(ctx)))
+            .collect()
+    }
+}
+
 /// Compute the negation of a value.
 fn neg(ctx: &mut EvalContext, span: Span, value: Value) -> Value {
     use Value::*;