work

src/parser/nodes/expr.rs

@@ -0,0 +1,55 @@
+pub use super::*;
+
+pub enum Expr {
+    Ident(Id<Ident>),
+    Lit(Id<Lit>),
+    Negate(Id<Expr>),
+    Assign(Id<Expr>, Id<Expr>),
+}
+
+impl Parsable for Expr {
+    fn parse(ctx: &mut ParseCtx) -> Result<Self, CompilerMsg> {
+        let e1 = match ctx.expect_next()? {
+            Token::Dash => Self::Negate(ctx.parse()?),
+            Token::Ident(s) => Self::Ident(ctx.ident(s)),
+            Token::Lit(l) => Self::Lit(ctx.lit(l)),
+            other => return ctx.unexpected(other, "an expression"),
+        };
+        let Some(next) = ctx.peek() else {
+            return Ok(e1);
+        };
+        Ok(match next {
+            Token::Equal => {
+                let e1 = ctx.push_adv(e1);
+                let e2: Id<Expr> = ctx.parse()?;
+                Expr::Assign(e1, e2)
+            }
+            _ => e1,
+        })
+    }
+}
+
+impl FmtNode for Expr {
+    fn fmt(&self, f: &mut std::fmt::Formatter, ctx: DisplayCtx) -> std::fmt::Result {
+        match *self {
+            Expr::Ident(id) => id.fmt(f, ctx),
+            Expr::Lit(id) => id.fmt(f, ctx),
+            Expr::Negate(id) => {
+                write!(f, "-{}", id.dsp(ctx))
+            }
+            Expr::Assign(id1, id2) => {
+                write!(f, "{} = {}", id1.dsp(ctx), id2.dsp(ctx))
+            }
+        }
+    }
+}
+
+impl FmtNode for Lit {
+    fn fmt(&self, f: &mut std::fmt::Formatter, _: DisplayCtx) -> std::fmt::Result {
+        match self {
+            Lit::Number(v) => write!(f, "{v}"),
+            Lit::Bool(v) => write!(f, "{v}"),
+            Lit::String(v) => write!(f, "{v}"),
+        }
+    }
+}