feat: parse match

Author: LynithDev

packages/engine/src/component.rs

@@ -82,14 +82,31 @@ pub trait ComponentIter<'a, C, T, I> where
 
     /// Expects a item to be there
     fn expect(&mut self, expected: &C) -> std::result::Result<T, Option<T>> {
-        let Some(item) = self.next_if_eq(expected) else {
+        let Some(item) = self.peek() else {
             return Err(None);
         };
 
-        if &item == expected {
-            Ok(item)
+        if expected == item {
+            let cloned = item.clone();
+            self.next();
+            Ok(cloned)
+        } else {
+            Err(Some(item.clone()))
+        }
+    }
+
+    /// Expects one of an item to be there
+    fn expect_any(&mut self, expected: &[C]) -> std::result::Result<T, Option<T>> {
+        let Some(item) = self.peek() else {
+            return Err(None);
+        };
+
+        if expected.iter().any(|t| t == item) {
+            let cloned = item.clone();
+            self.next();
+            Ok(cloned)
         } else {
-            Err(Some(item))
+            Err(Some(item.clone()))
         }
     }
 

packages/engine/src/cursor.rs

@@ -1,4 +1,4 @@
-use std::fmt::Debug;
+use std::{fmt::Debug, hash::Hash};
 
 #[derive(Clone, Copy, Eq)]
 pub struct Cursor(u16, u16, u32);
@@ -15,6 +15,13 @@ impl PartialEq for Cursor {
     }
 }
 
+impl Hash for Cursor {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.hash(state);
+        self.1.hash(state);
+    }
+}
+
 impl Cursor {
     pub fn create() -> Self {
         Self::from(1, 1)
@@ -61,7 +68,7 @@ impl Cursor {
     } 
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct WithCursor<T> {
     pub value: T,
     pub start: Cursor,

packages/engine/src/parser/ast.rs

@@ -1,4 +1,4 @@
-use std::fmt::Debug;
+use std::{collections::HashMap, fmt::Debug, rc::Rc};
 
 use crate::{cursor::WithCursor, lexer::tokens::{LexerToken, LexerTokenKind, ShellCommand}};
 
@@ -17,10 +17,12 @@ pub enum Expression {
     Identifier(Box<Identifier>),
     FunctionCall(Box<(Identifier, Vec<WithCursor<Expression>>)>),
     If(Box<(WithCursor<Expression>, WithCursor<Block>, Option<Else>)>),
-    Match(Box<(Expression, Vec<(Expression, Expression)>)>),
+    Match(Box<(WithCursor<Expression>, MatchCase)>),
+    Block(Box<Block>),
 }
 
 pub type Else = WithCursor<Block>;
+pub type MatchCase = HashMap<WithCursor<Literal>, Rc<WithCursor<Expression>>>;
 
 
 #[derive(lang_macro::EnumVariants, Debug, Clone, PartialEq, Eq)]
@@ -29,6 +31,7 @@ pub enum Statement {
     For(Box<(Variable, WithCursor<Expression>, WithCursor<Block>)>),
     Return(Box<Option<WithCursor<Expression>>>),
     If(Box<WithCursor<Expression>>),
+    Match(Box<WithCursor<Expression>>),
     Expression(Box<WithCursor<Expression>>),
     Continue,
     Break,
@@ -44,7 +47,7 @@ pub type ProgramTree = Block;
 pub type Identifier = String;
 pub type Block = Vec<Statement>;
 
-#[derive(lang_macro::EnumVariants, Debug, Clone, PartialEq, Eq)]
+#[derive(lang_macro::EnumVariants, Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Literal {
     Integer(isize),
     Boolean(bool),

packages/engine/src/parser/error.rs

@@ -8,7 +8,7 @@ pub enum ParserErrorKind {
     EngineError(#[from] crate::error::EngineErrorKind),
     #[error("couldn't convert lexer token {0} to ast node")]
     ConvertError(LexerTokenKind),
-    #[error("expected token '{0:?}' but found {1:?}")]
+    #[error("expected token '{0:?}' but found '{1:?}'")]
     ExpectedToken(Vec<LexerTokenKind>, Option<LexerTokenKind>),
     #[error("expected expression")]
     ExpectedExpression,