work

src/parser/nodes/item.rs

@@ -11,12 +11,18 @@ pub enum ItemTy {
         ty: Option<Type>,
         val: Expr,
     },
+    Fn(Func),
     Expr(Expr),
+    Import(Ident),
 }
 
 impl Node for Item {
     fn parse(ctx: &mut ParseCtx) -> Result<Self, CompilerMsg> {
         let ty = match ctx.expect_peek()? {
+            Token::Fn => {
+                ctx.next();
+                ItemTy::Fn(ctx.parse()?)
+            }
             Token::Let => {
                 ctx.next();
                 let name = ctx.parse()?;
@@ -28,6 +34,10 @@ impl Node for Item {
                 let val = ctx.parse()?;
                 ItemTy::Let { name, ty, val }
             }
+            Token::Import => {
+                ctx.next();
+                ItemTy::Import(ctx.parse()?)
+            }
             _ => ItemTy::Expr(ctx.parse()?),
         };
         Ok(Self {
@@ -38,6 +48,7 @@ impl Node for Item {
 
     fn fmt(&self, f: &mut std::fmt::Formatter, ctx: DisplayCtx) -> std::fmt::Result {
         match &self.ty {
+            ItemTy::Fn(func) => func.fmt(f, ctx)?,
             ItemTy::Let { name, ty, val } => {
                 write!(f, "let {}", name.dsp(ctx))?;
                 if let Some(ty) = ty {
@@ -45,7 +56,8 @@ impl Node for Item {
                 }
                 write!(f, " = {}", val.dsp(ctx))?;
             }
-            ItemTy::Expr(id) => id.fmt(f, ctx)?,
+            ItemTy::Expr(expr) => expr.fmt(f, ctx)?,
+            ItemTy::Import(ident) => write!(f, "import {}", ident.dsp(ctx))?,
         }
         Ok(())
     }
@@ -56,6 +68,8 @@ impl Item {
         match &self.ty {
             ItemTy::Let { val, .. } => val.ends_with_block(),
             ItemTy::Expr(id) => id.ends_with_block(),
+            ItemTy::Fn(f) => f.ends_with_block(),
+            ItemTy::Import(ident) => false,
         }
     }
     pub fn needs_semicolon(&self) -> bool {