From fbf6726a78174372950c95f3216728692a447cc6 Mon Sep 17 00:00:00 2001
From: Jooris Hadeler <j.hadeler@outlook.com>
Date: Fri, 16 Jan 2026 21:02:14 +0100
Subject: [PATCH] feat: Add parsing support for primitive types.

---
 example/simple.bky |  4 ++++
 src/ast.rs         |  9 ++++++++
 src/main.rs        |  2 +-
 src/parser.rs      | 53 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 67 insertions(+), 1 deletion(-)
 create mode 100644 example/simple.bky

diff --git a/example/simple.bky b/example/simple.bky
new file mode 100644
index 0000000..e1b7dd6
--- /dev/null
+++ b/example/simple.bky
@@ -0,0 +1,4 @@
+fn main(): i32 {
+    let return_code: i32 = 12;
+    return return_code;
+}
\ No newline at end of file
diff --git a/src/ast.rs b/src/ast.rs
index a2ba59a..cced20e 100644
--- a/src/ast.rs
+++ b/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 },
+}
diff --git a/src/main.rs b/src/main.rs
index d1ea654..bd8f197 100644
--- a/src/main.rs
+++ b/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());
 }
diff --git a/src/parser.rs b/src/parser.rs
index 5c61d4e..8268876 100644
--- a/src/parser.rs
+++ b/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_,
         })
     }