wip

src/parse/macros.rs

@@ -0,0 +1,55 @@
+#[macro_export]
+macro_rules! expect_token {
+    ($self:ident, $expect:pat) => {
+        let t = $self.consume();
+        if !matches!(t.kind, $expect) {
+            todo!("Expected token, found {:?}", t.kind)
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! expect_identifier {
+    ($self:ident) => {{
+        let t = $self.consume();
+        if !matches!(t.kind, TokenKind::Identifier(_)) {
+            todo!("Expected token, found {:?}", t.kind)
+        }
+        t
+    }};
+}
+
+#[macro_export]
+macro_rules! expect_any_keyword {
+    ($self:ident) => {{
+        let t = $self.consume();
+        if !matches!(t.kind, TokenKind::Keyword(_)) {
+            todo!("Expected token, found {:?}", t.kind)
+        }
+        t
+    }};
+}
+
+#[macro_export]
+macro_rules! expect_keyword {
+    ($self:ident, $keyword:pat) => {
+        let t = $self.consume();
+        if !matches!(t.kind, TokenKind::Keyword($keyword)) {
+            todo!("Expected token, found {:?}", t.kind)
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! peek_keyword {
+    ($self:ident, $keyword:pat) => {
+        matches!($self.peek().kind, TokenKind::Keyword($keyword))
+    };
+}
+
+#[macro_export]
+macro_rules! peek_match {
+    ($self:ident, $p:pat) => {
+        matches!($self.peek().kind, $p)
+    };
+}

src/parse/mod.rs

@@ -0,0 +1,77 @@
+mod macros;
+
+use crate::{
+    ast, expect_any_keyword, expect_identifier, expect_keyword, expect_token, peek_keyword,
+    peek_match,
+    token::{KeywordKind, Token, TokenKind},
+};
+
+pub struct Parser {
+    tokens: Vec<Token>,
+    current: usize,
+}
+
+impl Parser {
+    pub fn new(tokens: Vec<Token>) -> Parser {
+        Self { tokens, current: 0 }
+    }
+
+    pub fn statement(&mut self) -> ast::Statement {
+        if peek_keyword!(self, KeywordKind::function) {
+            return self.function_declaration();
+        }
+        return self.expression_statement();
+        todo!("No statement");
+    }
+
+    fn function_declaration(&mut self) -> ast::Statement {
+        expect_keyword!(self, KeywordKind::function);
+        let id = expect_identifier!(self);
+        expect_token!(self, TokenKind::LeftParen);
+
+        let mut parameters = Vec::new();
+        while peek_match!(self, TokenKind::Identifier(_)) {
+            let name = expect_identifier!(self);
+            expect_token!(self, TokenKind::Colon);
+            let typename = expect_any_keyword!(self);
+            let parameter = ast::ParameterDeclaration {
+                name: name.clone(),
+                typename: typename.clone(),
+            };
+            parameters.push(parameter);
+        }
+
+        expect_token!(self, TokenKind::RightParen);
+
+        expect_token!(self, TokenKind::LeftCurly);
+
+        let mut statements = Vec::new();
+        while !peek_match!(self, TokenKind::RightCurly) {
+            let statement = self.statement();
+            statements.push(statement);
+        }
+
+        expect_token!(self, TokenKind::RightCurly);
+
+        ast::Statement::FunctionDeclaration {
+            name: id.clone(),
+            parameters,
+            statements,
+        }
+    }
+
+    fn expression_statement(&mut self) -> ast::Statement {
+        todo!()
+    }
+}
+
+impl Parser {
+    fn peek(&self) -> &Token {
+        &self.tokens[self.current]
+    }
+    fn consume(&mut self) -> Token {
+        let token = &self.tokens[self.current];
+        self.current += 1;
+        token.clone()
+    }
+}