feat: default arm for match

src/generator/js.rs

@@ -168,10 +168,18 @@ fn generate_continue() -> String {
 
 fn generate_match(subject: Expression, arms: Vec<MatchArm>) -> String {
     let mut out_str = format!("switch ({E}) {{\n", E = generate_expression(subject));
-    for (case, statement) in arms {
-        out_str += &format!("case {}:\n", generate_expression(case));
-        out_str += &format!("{}\n", &generate_statement(statement));
-        out_str += "break;";
+    for arm in arms {
+        match arm {
+            MatchArm::Case(expr, statement) => {
+                out_str += &format!("case {}:\n", generate_expression(expr));
+                out_str += &format!("{}\n", &generate_statement(statement));
+                out_str += "break;";
+            }
+            MatchArm::Default(statement) => {
+                out_str += "default:\n";
+                out_str += &format!("{}\n", &generate_statement(statement));
+            }
+        }
     }
 
     out_str += "}";

src/parser/node_type.rs

@@ -20,8 +20,6 @@ use std::collections::HashMap;
 /// Table that contains all symbol and its types
 pub type SymbolTable = HashMap<String, Option<Type>>;
 
-pub type MatchArm = (Expression, Statement);
-
 #[derive(Debug)]
 pub struct Program {
     pub func: Vec<Function>,
@@ -144,6 +142,12 @@ impl TryFrom<Token> for Expression {
     }
 }
 
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub enum MatchArm {
+    Case(Expression, Statement),
+    Default(Statement)
+}
+
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub enum BinOp {
     Addition,

src/parser/rules.rs

@@ -492,11 +492,22 @@ impl Parser {
     }
 
     fn parse_match_arm(&mut self) -> Result<MatchArm, String> {
-        let expr = self.parse_expression()?;
-        self.match_token(TokenKind::ArrowRight)?;
-        let statement = self.parse_statement()?;
+        let next = self.peek()?;
 
-        Ok((expr, statement))
+        match next.kind {
+            TokenKind::Keyword(Keyword::Default) => {
+                self.match_keyword(Keyword::Default)?;
+                self.match_token(TokenKind::ArrowRight)?;
+                return Ok(MatchArm::Default(self.parse_statement()?));
+            }
+            _ => {
+                let expr = self.parse_expression()?;
+                self.match_token(TokenKind::ArrowRight)?;
+                let statement = self.parse_statement()?;
+
+                Ok(MatchArm::Case(expr, statement))
+            }
+        }
     }
 
     fn parse_conditional_statement(&mut self) -> Result<Statement, String> {

tests/match_statements.sb

@@ -26,7 +26,7 @@ fn test_match_with_block_statement() {
             println("x is 2, in case you are wondering")
         }
         42 => println("The answer to the universe and everything!")
-        // default => println("Default case")
+        default => println("Default case")
     }
 }