add if parser

Author: stringhandler

src/lexer.rs

@@ -21,19 +21,33 @@ pub enum Token<'src> {
     Else,
 
     // Control symbols
+    /// `->``
     Arrow,
+    /// `:`
     Colon,
+    /// `;`
     Semi,
+    /// `,`
     Comma,
+    /// `=`
     Eq,
+    /// `=>`
     FatArrow,
+    /// `(`
     LParen,
+    /// `)`
     RParen,
+    /// `[`
     LBracket,
+    /// `]`
     RBracket,
+    /// `{`
     LBrace,
+    /// `}`
     RBrace,
+    /// `<`
     LAngle,
+    /// `>`
     RAngle,
 
     // Number literals
@@ -257,29 +271,86 @@ mod tests {
         (tokens, errors)
     }
 
+    /// Helper function to get the variant name of a token
+    fn variant_name(token: &Token) -> &'static str {
+        match token {
+            Token::Fn => "Fn",
+            Token::Let => "Let",
+            Token::Type => "Type",
+            Token::Mod => "Mod",
+            Token::Const => "Const",
+            Token::Match => "Match",
+            Token::If => "If",
+            Token::Else => "Else",
+            Token::Arrow => "Arrow",
+            Token::Colon => "Colon",
+            Token::Semi => "Semi",
+            Token::Comma => "Comma",
+            Token::Eq => "Eq",
+            Token::FatArrow => "FatArrow",
+            Token::LParen => "LParen",
+            Token::RParen => "RParen",
+            Token::LBracket => "LBracket",
+            Token::RBracket => "RBracket",
+            Token::LBrace => "LBrace",
+            Token::RBrace => "RBrace",
+            Token::LAngle => "LAngle",
+            Token::RAngle => "RAngle",
+            Token::DecLiteral(_) => "DecLiteral",
+            Token::HexLiteral(_) => "HexLiteral",
+            Token::BinLiteral(_) => "BinLiteral",
+            Token::Bool(_) => "Bool",
+            Token::Ident(_) => "Ident",
+            Token::Jet(_) => "Jet",
+            Token::Witness(_) => "Witness",
+            Token::Param(_) => "Param",
+            Token::Macro(_) => "Macro",
+            Token::Comment => "Comment",
+            Token::BlockComment => "BlockComment",
+        }
+    }
+
+    /// Macro to assert that a sequence of tokens matches the expected variant types
+    macro_rules! assert_tokens_match {
+        ($tokens:expr, $($expected:ident),* $(,)?) => {
+            {
+                let tokens = $tokens.as_ref().expect("Expected Some tokens");
+                let expected_variants = vec![$( stringify!($expected) ),*];
+
+                assert_eq!(
+                    tokens.len(),
+                    expected_variants.len(),
+                    "Expected {} tokens, got {}.\nTokens: {:?}",
+                    expected_variants.len(),
+                    tokens.len(),
+                    tokens
+                );
+
+                for (idx, (token, expected_variant)) in tokens.iter().zip(expected_variants.iter()).enumerate() {
+                    let actual_variant = variant_name(token);
+                    assert_eq!(
+                        actual_variant,
+                        *expected_variant,
+                        "Token at index {} does not match: expected {}, got {} (token: {:?})",
+                        idx,
+                        expected_variant,
+                        actual_variant,
+                        token
+                    );
+                }
+            }
+        };
+    }
+
     #[test]
     fn test_if_statement() {
         let input = "if true {0} else {1};";
         let (tokens, errors) = lex(input);
         assert!(errors.is_empty(), "Expected no errors, found: {:?}", errors);
 
-        assert_eq!(
-            tokens,
-            Some(vec![
-                Token::If,
-                Token::Bool(true,),
-                Token::LBrace,
-                Token::DecLiteral(Decimal(Arc::new("0"))),
-                Token::RBrace,
-                Token::Else,
-                Token::LBrace,
-                Token::DecLiteral(Decimal(Arc::new("1"))),
-                Token::RBrace,
-                Token::Semi,
-            ])
+        assert_tokens_match!(
+            tokens, If, Bool, LBrace, DecLiteral, RBrace, Else, LBrace, DecLiteral, RBrace, Semi,
         );
-        dbg!(tokens);
-        todo!("Finish");
     }
 
     #[test]

src/parse.rs

@@ -1642,6 +1642,8 @@ impl SingleExpression {
 
         let match_expr = Match::parser(expr.clone()).map(SingleExpressionInner::Match);
 
+        let if_expr = If::parser(expr.clone()).map(SingleExpressionInner::If);
+
         let variable = Identifier::parser().map(SingleExpressionInner::Variable);
 
         // Expression delimeted by parentheses
@@ -1651,8 +1653,8 @@ impl SingleExpression {
             .map(|es| SingleExpressionInner::Expression(Arc::from(es)));
 
         choice((
-            left, right, some, none, boolean, match_expr, expression, list, array, tuple, call,
-            literal, variable,
+            left, right, some, none, boolean, match_expr, if_expr, expression, list, array, tuple,
+            call, literal, variable,
         ))
         .map_with(|inner, e| Self {
             inner,
@@ -1816,6 +1818,35 @@ impl Match {
     }
 }
 
+impl If {
+    fn parser<'tokens, 'src: 'tokens, I, E>(
+        expr: E,
+    ) -> impl Parser<'tokens, I, Self, ParseError<'src>> + Clone
+    where
+        I: ValueInput<'tokens, Token = Token<'src>, Span = Span>,
+        E: Parser<'tokens, I, Expression, ParseError<'src>> + Clone + 'tokens,
+    {
+        let scrutinee = expr.clone().map(Arc::new);
+
+        let true_arm = expr.clone().map(Arc::new);
+        let false_arm = expr.clone().map(Arc::new);
+        // let true_arm = delimited_with_recovery(Expression::parser, Token::LBrace, Token::RBrace, |_| None);
+        // let false_arm = delimited_with_recovery(Expression::parser, Token::LBrace, Token::RBrace, |_| None);
+
+        just(Token::If)
+            .ignore_then(scrutinee)
+            .then(true_arm)
+            .then_ignore(just(Token::Else))
+            .then(false_arm)
+            .map_with(|((s, t), el), extra| Self {
+                scrutinee: s,
+                then_arm: t,
+                else_arm: el,
+                span: extra.span(),
+            })
+    }
+}
+
 impl ChumskyParse for ModuleItem {
     fn parser<'tokens, 'src: 'tokens, I>() -> impl Parser<'tokens, I, Self, ParseError<'src>> + Clone
     where
@@ -2212,3 +2243,27 @@ impl crate::ArbitraryRec for Match {
         })
     }
 }
+
+#[cfg(test)]
+mod test {
+
+    use super::*;
+    #[test]
+    fn test_if_statement_parse() {
+        // let input: Arc<str> = "if true {0} else {1};".into();
+        let input = "if true {0} else {1}";
+
+        let statement = Expression::parse_from_str(input).expect("Error");
+
+        match &statement.inner() {
+            ExpressionInner::Single(se) => match se.inner() {
+                SingleExpressionInner::If(if_) => {
+                    dbg!(if_);
+                    // pass
+                }
+                _ => panic!("Did not find if statement correctly"),
+            },
+            _ => panic!("Did not parse correctly"),
+        }
+    }
+}