feat: Add parsing support for primitive types.

src/ast.rs

@@ -64,6 +64,7 @@ pub enum Statement {
     Let {
         name: Box<str>,
         name_span: Span,
+        type_: Option<Type>,
         value: Option<Expression>,
     },
 
@@ -94,3 +95,11 @@ pub enum Statement {
 
     Expr(Expression),
 }
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum Type {
+    Integer { size: u8, signed: bool },
+    Boolean,
+
+    Named { name: Box<str>, name_span: Span },
+}

src/main.rs

@@ -5,7 +5,7 @@ pub mod parser;
 pub mod token;
 
 fn main() {
-    let mut parser = Parser::new("break;");
+    let mut parser = Parser::new("{ let return_code: i32 = 12; return return_code; }");
 
     println!("{:#?}", parser.parse_statement());
 }

src/parser.rs

@@ -56,6 +56,50 @@ impl<'src> Parser<'src> {
         }
     }
 
+    pub fn parse_type(&mut self) -> ParserResult<Type> {
+        let name_tok = self.expect(&[TokenKind::Identifier])?;
+
+        Ok(match name_tok.text {
+            "i8" => Type::Integer {
+                size: 8,
+                signed: true,
+            },
+            "u8" => Type::Integer {
+                size: 8,
+                signed: false,
+            },
+            "i16" => Type::Integer {
+                size: 16,
+                signed: true,
+            },
+            "u16" => Type::Integer {
+                size: 16,
+                signed: false,
+            },
+            "i32" => Type::Integer {
+                size: 32,
+                signed: true,
+            },
+            "u32" => Type::Integer {
+                size: 32,
+                signed: false,
+            },
+            "i64" => Type::Integer {
+                size: 64,
+                signed: true,
+            },
+            "u64" => Type::Integer {
+                size: 64,
+                signed: false,
+            },
+            "bool" => Type::Boolean,
+            name => Type::Named {
+                name: name.to_string().into_boxed_str(),
+                name_span: name_tok.span,
+            },
+        })
+    }
+
     pub fn parse_statement(&mut self) -> ParserResult<Statement> {
         match self.peek_no_eof()?.kind {
             TokenKind::KwLet => self.parse_let_statement(),
@@ -63,6 +107,7 @@ impl<'src> Parser<'src> {
             TokenKind::KwLoop => self.parse_loop_statement(),
             TokenKind::KwBreak => self.parse_break_statement(),
             TokenKind::KwReturn => self.parse_return_statement(),
+            TokenKind::LeftBrace => self.parse_compound_statement(),
 
             _ => {
                 let expr = self.parse_expression(0)?;
@@ -147,6 +192,13 @@ impl<'src> Parser<'src> {
             (token.text.to_string().into_boxed_str(), token.span)
         };
 
+        let type_ = if self.is_peek(TokenKind::Colon) {
+            self.consume();
+            Some(self.parse_type()?)
+        } else {
+            None
+        };
+
         let value = if self.is_peek(TokenKind::Assign) {
             self.consume();
 
@@ -161,6 +213,7 @@ impl<'src> Parser<'src> {
             name,
             name_span,
             value,
+            type_,
         })
     }