nix: replace rust-overlay with fenix

Signed-off-by: Amneesh Singh <natto@weirdnatto.in>

flake.nix

@@ -9,25 +9,28 @@
       inputs.nixpkgs.follows = "nixpkgs";
     };
 
-    rust-overlay = {
-      url = github:oxalica/rust-overlay;
+    fenix = {
+      url = github:nix-community/fenix;
       inputs.nixpkgs.follows = "nixpkgs";
     };
 
     flake-utils.url = github:numtide/flake-utils;
   };
 
-  outputs = inputs@{ self, nixpkgs, crane, rust-overlay, flake-utils }:
+  outputs = inputs@{ self, nixpkgs, crane, fenix, flake-utils }:
     flake-utils.lib.eachDefaultSystem (system:
       let
         pkgs = import nixpkgs {
           inherit system;
-          overlays = [ rust-overlay.overlays.default ];
+          overlays = [ fenix.overlays.default ];
         };
 
         inherit (pkgs) lib;
 
-        toolchain = pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
+        toolchain = pkgs.fenix.fromToolchainFile {
+          file = ./rust-toolchain.toml;
+          sha256 = "sha256-n8LtGbpj/yCUGo0NFJ7FNv9fSdT9oKEUl+EPLg06JdQ=";
+        };
 
         craneLib = (crane.mkLib pkgs).overrideToolchain toolchain;
         src = craneLib.cleanCargoSource (craneLib.path ./.);

src/args.rs

@@ -1,4 +1,5 @@
 use std::env;
+use std::path::PathBuf;
 use std::process::exit;
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -8,7 +9,7 @@ const CRATE: &str = env!("CARGO_CRATE_NAME");
 #[derive(Default)]
 pub struct Args {
     version: bool,
-    file: Option<String>,
+    file: Option<PathBuf>,
 }
 
 impl Args {
@@ -34,7 +35,7 @@ impl Args {
                     if self.file.is_some() {
                         panic!("please specify only a single source file!");
                     }
-                    self.file = Some(file.to_owned());
+                    self.file = Some(PathBuf::from(file));
                 }
             }
         }
@@ -55,7 +56,7 @@ impl Args {
     /// Fetches the file from the arguments.
     /// Panics if there is no file in the arguments
     #[inline]
-    pub fn get_file(self) -> String {
+    pub fn get_file(self) -> PathBuf {
         self.file.expect("no file supplied!")
     }
 }

src/ast.rs

@@ -1,89 +1,132 @@
-/// A very naive AST definition using recursive enums
-/// See the parser for implementation
+//! A very naive AST definition using recursive enums
+//!
+//! See the parser for implementation
 
 use std::rc::Rc;
 
 pub type Parent = Vec<Entity>;
 
 /// Entities are functions, classes, and modules
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum Entity {
     Fn(Fn),
     Class(Class),
     Module(Module),
+    Static(Let),
 }
 
-#[derive(Debug)]
+/// A module just provides an additional scope
+///
+/// TODO: Add exporting and importing modules
+#[derive(Debug, PartialEq)]
 pub struct Module {
+    /// Name of module
     pub name: Rc<str>,
+    /// Everything inside the module
     pub children: Vec<ModuleChildren>,
 }
 
 /// Modules contain functions, classes and statements
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum ModuleChildren {
     Fn(Fn),
     Class(Class),
-    Statement(Statement),
+    Module(Module),
+    Static(Let),
 }
 
-#[derive(Debug)]
+/// Classes encapsulate functions and definitions.
+#[derive(Debug, PartialEq)]
 pub struct Class {
+    /// Name of class
     pub name: Rc<str>,
+    /// Everything inside the class
     pub children: Vec<ClassChildren>,
 }
 
-/// Classes contain functions and statements.
-///
-/// TODO: Maybe change statements to something else
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum ClassChildren {
     Fn(Fn),
-    Statement(Statement),
+    Let(Let),
+    Static(Let),
 }
 
-#[derive(Debug)]
+/// A Function
+#[derive(Debug, PartialEq)]
 pub struct Fn {
+    /// Name of the function
     pub name: Rc<str>,
-    pub return_typ: Option<Primitive>,
-    pub params: Vec<(Rc<str>, Primitive)>,
+    /// Optional return type
+    pub return_ty: Option<Ty>,
+    /// Parameters
+    pub params: Vec<(Rc<str>, Ty)>,
+    /// The function block
     pub children: Vec<Statement>,
 }
 
-#[derive(Debug)]
+/// Statements encapsulate expressions and definitions
+#[derive(Debug, PartialEq)]
 pub enum Statement {
+    Static(Let),
     Let(Let),
     Expr(Expr),
-    Block(Vec<Statement>),
 }
 
-#[derive(Debug)]
+/// A variable definition
+#[derive(Debug, PartialEq)]
 pub struct Let {
+    /// Name of variabe
     pub name: Rc<str>,
-    pub typ: Primitive,
+    /// Type of variable
+    pub ty: Ty,
+    /// Value of variable
     pub expr: Option<Expr>,
 }
 
-type Op = crate::lexer::TokenSymbol;
-
-#[derive(Debug)]
-pub enum Expr {
-    Int(i32),
-    Float(f32),
-    Char(char),
-    Op(Op, Box<Expr>, Option<Box<Expr>>),
-    If(Box<Expr>, Box<Expr>, Option<Box<Expr>>),
-    Loop,
-    Break,
-    Continue,
-}
-
 /// Primitives
 ///
 /// TODO: add arrays and pointers maybe
-#[derive(Debug)]
-pub enum Primitive {
+#[derive(Debug, PartialEq)]
+pub enum Ty {
     Int,
     Float,
     Char,
 }
+
+#[derive(Debug, PartialEq)]
+pub struct If {
+    pub cond: Box<Expr>,
+    pub then: Vec<Statement>,
+    pub or: Option<Box<ElseType>>,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum ElseType {
+    If(If),
+    Else(Vec<Statement>),
+}
+
+pub(crate) type Op = crate::lexer::TokenSymbol;
+
+#[derive(Debug, PartialEq)]
+pub enum Literal {
+    Int(i32),
+    Float(f32),
+    Char(char),
+}
+
+/// Lowest form of expression
+///
+/// TODO: refine
+#[derive(Debug, PartialEq)]
+pub enum Expr {
+    Literal(Literal),
+    Identifier(Rc<str>),
+    Op(Op, Box<Expr>, Option<Box<Expr>>),
+    If(If),
+    Block(Vec<Statement>),
+    Loop(Vec<Statement>),
+    Break,
+    Continue,
+    Return(Option<Box<Expr>>),
+}

src/lexer.rs

@@ -6,7 +6,7 @@ use std::str;
 /// All token literals
 ///
 /// TODO: Add string
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 pub enum TokenLiteral {
     Int,
     Float,
@@ -14,11 +14,9 @@ pub enum TokenLiteral {
 }
 
 /// All token symbols
-///
-/// TODO: Maybe add *
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 pub enum TokenSymbol {
-    // operators
+    // arithmetic
     Plus,
     Minus,
     Star,
@@ -40,9 +38,7 @@ pub enum TokenSymbol {
 
     // relational
     Gt,
-    Ge,
     Lt,
-    Le,
     GtEq,
     LtEq,
     EqEq,
@@ -69,7 +65,7 @@ pub enum TokenSymbol {
 }
 
 /// All token keywod
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 pub enum TokenKeyword {
     // parents
     Fn,
@@ -77,6 +73,7 @@ pub enum TokenKeyword {
     Module,
 
     // statements
+    Static,
     Let,
     Ret,
 
@@ -89,6 +86,7 @@ pub enum TokenKeyword {
     Loop,
     Break,
     Continue,
+    Return,
 
     // primitives
     Int,
@@ -99,7 +97,7 @@ pub enum TokenKeyword {
 /// All token delimiters
 ///
 /// TODO: Maybe add \[ and \]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 pub enum TokenDelimiter {
     BraceOpen,
     BraceClose,
@@ -108,7 +106,7 @@ pub enum TokenDelimiter {
 }
 
 /// All tokens
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 pub enum TokenKind {
     Newline,
     Eof,
@@ -138,9 +136,10 @@ pub struct Lexer<'a> {
     /// A peekable double ended queue for the tokens
     tokens: VecDeque<Token>,
     /// Current line number
-    pub line: usize,
+    pub(crate) line: usize,
+    pub(crate) col: usize,
     /// Start character index for the current token
-    pub start: usize,
+    start: usize,
     /// End character index for the current token
     end: usize,
 }
@@ -172,6 +171,7 @@ impl<'a> Lexer<'a> {
             chars: content.chars().peekable(),
             tokens: VecDeque::new(),
             line: 1,
+            col: 1,
             start: 0,
             end: 0,
         }
@@ -198,6 +198,7 @@ impl<'a> Lexer<'a> {
     #[inline]
     fn next(&mut self) -> Option<char> {
         self.end += 1;
+        self.col += 1;
         self.chars.next()
     }
 
@@ -233,11 +234,16 @@ impl<'a> Lexer<'a> {
                 '0'..='9' => {}
                 '.' => {
                     if is_float {
-                        self.error("Multiple decimals encountered");
+                        self.error("multiple decimals encountered");
                         return self.new_token(TokenKind::Invalid);
                     }
                     is_float = true;
                 }
+                'e' | 'E' => {
+                    self.next();
+                    is_float = true;
+                    break;
+                }
                 _ => break,
             }
             self.next();
@@ -259,6 +265,11 @@ impl<'a> Lexer<'a> {
             return self.new_token(TokenKind::Invalid);
         }
 
+        if self.peek() != Some(&'\'') {
+            self.error("Expected '");
+            return self.new_token(TokenKind::Invalid);
+        }
+
         // skip '
         self.next();
 
@@ -268,7 +279,7 @@ impl<'a> Lexer<'a> {
     fn get_alphanumeric(&mut self) -> Token {
         while let Some(c) = self.peek() {
             match c {
-                'a'..='z' | 'A'..='Z' | '0'..='9' => {}
+                'a'..='z' | 'A'..='Z' | '0'..='9' | '_' => {}
                 _ => break,
             }
             self.next();
@@ -281,6 +292,7 @@ impl<'a> Lexer<'a> {
             "fn" => Keyword(Fn),
             "class" => Keyword(Class),
             "module" => Keyword(Module),
+            "static" => Keyword(Static),
             "let" => Keyword(Let),
             "ret" => Keyword(Ret),
             "if" => Keyword(If),
@@ -289,6 +301,7 @@ impl<'a> Lexer<'a> {
             "loop" => Keyword(Loop),
             "break" => Keyword(Break),
             "continue" => Keyword(Continue),
+            "return" => Keyword(Return),
             "int" => Keyword(Int),
             "float" => Keyword(Float),
             "char" => Keyword(Char),
@@ -392,10 +405,11 @@ impl<'a> Lexer<'a> {
                 '\n' => {
                     self.next();
                     self.line += 1;
+                    self.col = 0;
                     self.new_token(TokenKind::Newline)
                 }
                 '0'..='9' => self.get_numeric(),
-                'a'..='z' | 'A'..='Z' => self.get_alphanumeric(),
+                'a'..='z' | 'A'..='Z' | '_' => self.get_alphanumeric(),
                 '\'' => self.get_char(),
                 _ => self.get_symbol(),
             }
@@ -441,7 +455,7 @@ fn test_peek_next() {
 }
 
 #[test]
-fn test_tokens_1() {
+fn test_tokens() {
     let mut lexer = Lexer::new("let test02 = 4 << 1");
 
     use TokenKind::*;
@@ -501,9 +515,51 @@ fn test_tokens_2() {
 }
 
 #[test]
-fn test_tokens_3() {
+fn test_tokens_eof() {
     let mut lexer = Lexer::new("");
 
     assert_eq!(lexer.peek_token().kind, TokenKind::Eof);
     assert_eq!(lexer.next_token().kind, TokenKind::Eof);
 }
+
+#[test]
+fn test_tokens_numeric() {
+    let mut lexer = Lexer::new("3342");
+
+    let token = lexer.next_token();
+    assert_eq!(token.kind, TokenKind::Literal(TokenLiteral::Int));
+    assert_eq!(*token.val, *"3342");
+
+    assert_eq!(lexer.next_token().kind, TokenKind::Eof);
+}
+
+#[test]
+fn test_tokens_numeric_2() {
+    let mut lexer = Lexer::new("334.2e");
+
+    let token = lexer.next_token();
+    assert_eq!(token.kind, TokenKind::Literal(TokenLiteral::Float));
+    assert_eq!(*token.val, *"334.2e");
+
+    assert_eq!(lexer.next_token().kind, TokenKind::Eof);
+}
+
+#[test]
+fn test_tokens_numeric_3() {
+    let mut lexer = Lexer::new("334.2e-5");
+
+    let mut token = lexer.next_token();
+    assert_eq!(token.kind, TokenKind::Literal(TokenLiteral::Float));
+    assert_eq!(*token.val, *"334.2e");
+
+    assert_eq!(
+        lexer.next_token().kind,
+        TokenKind::Symbol(TokenSymbol::Minus)
+    );
+
+    token = lexer.next_token();
+    assert_eq!(token.kind, TokenKind::Literal(TokenLiteral::Int));
+    assert_eq!(*token.val, *"5");
+
+    assert_eq!(lexer.next_token().kind, TokenKind::Eof);
+}

src/lib.rs

@@ -1,3 +1,4 @@
 pub mod args;
 pub mod ast;
 pub mod lexer;
+pub mod parser;

src/main.rs

@@ -4,10 +4,7 @@ use std::{
 };
 
 use tricc::args::Args;
-use tricc::lexer::{
-    Lexer,
-    TokenKind,
-};
+use tricc::parser::Parser;
 
 fn main() {
     panic::set_hook(Box::new(|panic_info| {
@@ -31,10 +28,13 @@ fn main() {
 
     let file = args.get_file();
     let content = fs::read_to_string(&file).expect("Couldn't read the file");
-
-    let mut lexer = Lexer::new(content.as_str());
-
-    while lexer.peek_token().kind != TokenKind::Eof {
-        println!("{:?}", lexer.next_token());
-    }
+    let mut parser = Parser::new(&content);
+    let Some(parent) = parser.parse() else {
+        eprintln!(
+            "Failed to parse {} - See the errors above",
+            file.to_string_lossy()
+        );
+        std::process::exit(1);
+    };
+    println!("Parsed AST:\n{:#?}", parent);
 }

src/parser/entity.rs

@@ -0,0 +1,215 @@
+use super::Parser;
+use crate::ast::*;
+use crate::lexer::{
+    TokenDelimiter,
+    TokenKeyword,
+    TokenKind,
+    TokenSymbol,
+};
+use std::rc::Rc;
+
+impl<'a> Parser<'a> {
+    /// entity ::= module | class | fn | static
+    pub(super) fn parse_entity(&mut self) -> Option<Entity> {
+        use TokenKeyword::*;
+        let token = self.peek_token();
+
+        if let TokenKind::Keyword(keyword) = &token.kind {
+            Some(match keyword {
+                Module => Entity::Module(self.parse_module()?),
+                Class => Entity::Class(self.parse_class()?),
+                Fn => Entity::Fn(self.parse_fn()?),
+                Static => Entity::Static(self.parse_static()?),
+                _ => {
+                    self.error_expected_peek("entity");
+                    return None;
+                }
+            })
+        } else {
+            self.error_expected_peek("entity");
+            None
+        }
+    }
+
+    /// module ::= "module" ident "{" { module | fn | static | class } "}"
+    fn parse_module(&mut self) -> Option<Module> {
+        self.next_token();
+
+        let name = self.parse_ident()?;
+        let mut children = vec![];
+
+        if !self.skip_token(TokenKind::Delimiter(TokenDelimiter::BraceOpen)) {
+            self.error_expected_peek("{");
+            return None;
+        }
+
+        loop {
+            use TokenKeyword::*;
+            self.trim_newlines();
+            if let TokenKind::Keyword(keyword) = &self.peek_token().kind {
+                children.push(match keyword {
+                    Module => ModuleChildren::Module(self.parse_module()?),
+                    Fn => ModuleChildren::Fn(self.parse_fn()?),
+                    Static => ModuleChildren::Static(self.parse_static()?),
+                    Class => ModuleChildren::Class(self.parse_class()?),
+                    _ => {
+                        self.error_expected_peek("module child");
+                        return None;
+                    }
+                });
+                if !self.check_newline_or_tok(TokenKind::Delimiter(TokenDelimiter::BraceClose)) {
+                    self.error_expected_peek("newline or }");
+                    return None;
+                }
+            } else if !self.skip_token(TokenKind::Delimiter(TokenDelimiter::BraceClose)) {
+                self.error_expected_peek("}");
+                return None;
+            } else {
+                break;
+            }
+        }
+
+        Some(Module { name, children })
+    }
+
+    /// class ::= "class" ident "{" { fn | static | let } "}"
+    fn parse_class(&mut self) -> Option<Class> {
+        self.next_token();
+
+        let name = self.parse_ident()?;
+        let mut children = vec![];
+
+        if !self.skip_token(TokenKind::Delimiter(TokenDelimiter::BraceOpen)) {
+            self.error_expected_peek("{");
+            return None;
+        }
+
+        loop {
+            use TokenKeyword::*;
+            self.trim_newlines();
+            if let TokenKind::Keyword(keyword) = &self.peek_token().kind {
+                children.push(match keyword {
+                    Fn => ClassChildren::Fn(self.parse_fn()?),
+                    Static => ClassChildren::Static(self.parse_static()?),
+                    Let => ClassChildren::Let(self.parse_let()?),
+                    _ => {
+                        self.error_expected_peek("class child");
+                        return None;
+                    }
+                });
+                if !self.check_newline_or_tok(TokenKind::Delimiter(TokenDelimiter::BraceClose)) {
+                    self.error_expected_peek("newline or }");
+                    return None;
+                }
+            } else if !self.skip_token(TokenKind::Delimiter(TokenDelimiter::BraceClose)) {
+                self.error_expected_peek("}");
+                return None;
+            } else {
+                break;
+            }
+        }
+
+        Some(Class { name, children })
+    }
+
+    /// fn ::= "fn" ident "(" [ identWithTy { "," identWithTy } ] ")" [ ":" ty ]
+    ///        "{" { statement } "}"
+    fn parse_fn(&mut self) -> Option<Fn> {
+        self.next_token();
+
+        let name = self.parse_ident()?;
+        let mut params: Vec<(Rc<str>, Ty)> = vec![];
+        let mut return_typ: Option<Ty> = None;
+        let mut children: Vec<Statement> = vec![];
+
+        if !self.skip_token(TokenKind::Delimiter(TokenDelimiter::ParenOpen)) {
+            self.error_expected_peek("(");
+            return None;
+        }
+
+        loop {
+            if self.peek_token().kind == TokenKind::Identifier {
+                params.push(self.parse_ident_with_ty()?);
+            }
+
+            if !self.skip_token(TokenKind::Symbol(TokenSymbol::Comma)) {
+                if !self.skip_token(TokenKind::Delimiter(TokenDelimiter::ParenClose)) {
+                    self.error_expected_peek(", or )");
+                    return None;
+                } else {
+                    break;
+                }
+            }
+        }
+
+        if self.skip_token(TokenKind::Symbol(TokenSymbol::Colon)) {
+            return_typ = Some(self.parse_ty()?);
+        }
+
+        if !self.skip_token(TokenKind::Delimiter(TokenDelimiter::BraceOpen)) {
+            self.error_expected_peek("{");
+            return None;
+        }
+
+        loop {
+            self.trim_newlines();
+            if self.skip_token(TokenKind::Delimiter(TokenDelimiter::BraceClose)) {
+                break;
+            }
+            children.push(self.parse_statement()?);
+            if !self.check_newline_or_tok(TokenKind::Delimiter(TokenDelimiter::BraceClose)) {
+                self.error_expected_peek("newline or }");
+                return None;
+            }
+        }
+
+        Some(Fn {
+            name,
+            return_ty: return_typ,
+            params,
+            children,
+        })
+    }
+}
+
+#[test]
+fn test_parse_entity() {
+    let mut parser = Parser::new(
+        r#"module module01 {
+             class class01 {
+               fn fn01(param01: char, param02: float) {
+                 static let let01: int = 4
+               }
+             }
+
+             fn fn02 (): int { }
+          }"#,
+    );
+    assert_eq!(
+        parser.parse_entity(),
+        Some(Entity::Module(Module {
+            name: "module01".into(),
+            children: vec![
+                ModuleChildren::Class(Class {
+                    name: "class01".into(),
+                    children: vec![ClassChildren::Fn(Fn {
+                        name: "fn01".into(),
+                        return_ty: None,
+                        params: vec![("param01".into(), Ty::Char), ("param02".into(), Ty::Float)],
+                        children: vec![Statement::Static(Let {
+                            name: "let01".into(),
+                            ty: Ty::Int,
+                            expr: Some(Expr::Literal(Literal::Int(4)))
+                        })]
+                    })]
+                }),
+                ModuleChildren::Fn(Fn {
+                    name: "fn02".into(),
+                    return_ty: Some(Ty::Int),
+                    params: vec![],
+                    children: vec![]
+                })
+            ]
+        }))
+    );
+}

src/parser/expr.rs

@@ -0,0 +1,435 @@
+use super::Parser;
+use crate::ast::{
+    self,
+    *,
+};
+use crate::lexer::{
+    TokenDelimiter,
+    TokenKeyword,
+    TokenKind,
+    TokenLiteral,
+    TokenSymbol,
+};
+use std::rc::Rc;
+
+impl<'a> Parser<'a> {
+    /// exprIf ::= "if" expr block [ else (block | exprIf ) ]
+    fn parse_expr_if(&mut self) -> Option<If> {
+        // skip "if"
+        self.next_token();
+
+        let cond = Box::new(self.parse_expr()?);
+        let then = self.parse_expr_block()?;
+
+        if !self.skip_token(TokenKind::Keyword(TokenKeyword::Else)) {
+            return Some(If {
+                cond,
+                then,
+                or: None,
+            });
+        }
+
+        if self.peek_token().kind != TokenKind::Keyword(TokenKeyword::If) {
+            return Some(If {
+                cond,
+                then,
+                or: Some(Box::new(ElseType::Else(self.parse_expr_block()?))),
+            });
+        }
+
+        Some(If {
+            cond,
+            then,
+            or: Some(Box::new(ElseType::If(self.parse_expr_if()?))),
+        })
+    }
+
+    /// exprBlock ::= "{" { statement } "}"
+    fn parse_expr_block(&mut self) -> Option<Vec<Statement>> {
+        let mut statements = vec![];
+
+        // skip {
+        self.next_token();
+
+        loop {
+            self.trim_newlines();
+            if self.skip_token(TokenKind::Delimiter(TokenDelimiter::BraceClose)) {
+                break;
+            }
+            statements.push(self.parse_statement()?);
+            if !self.check_newline_or_tok(TokenKind::Delimiter(TokenDelimiter::BraceClose)) {
+                self.error_expected_peek("newline or }");
+                return None;
+            }
+        }
+
+        Some(statements)
+    }
+
+    /// exprLoop ::= "loop" exprBlock
+    fn parse_expr_loop(&mut self) -> Option<Vec<Statement>> {
+        self.next_token();
+        if self.peek_token().kind != TokenKind::Delimiter(TokenDelimiter::BraceOpen) {
+            self.error_expected_peek("{");
+            return None;
+        }
+
+        self.parse_expr_block()
+    }
+
+    /// exprAtom ::= ( "(" expr ")" ) | ident | int | float | char | exprBlock | exprLoop | exprIf
+    fn parse_expr_atom(&mut self) -> Option<Expr> {
+        use ast::Literal::*;
+        use TokenKind::*;
+
+        // TODO: check lvalue validity in the analysis phase
+        Some(match self.peek_token().kind {
+            Delimiter(TokenDelimiter::ParenOpen) => {
+                self.next_token(); // skip (
+
+                let expr = self.parse_expr()?;
+
+                if !self.skip_token(TokenKind::Delimiter(TokenDelimiter::ParenClose)) {
+                    self.error_expected_peek(")");
+                    return None;
+                }
+
+                expr
+            }
+            Identifier => {
+                let token = self.next_token();
+                Expr::Identifier(Rc::clone(&token.val))
+            }
+            Literal(TokenLiteral::Int) => Expr::Literal(Int(self.parse_int()?)),
+            Literal(TokenLiteral::Float) => Expr::Literal(Float(self.parse_float()?)),
+            Literal(TokenLiteral::Char) => Expr::Literal(Char(self.parse_char()?)),
+            Delimiter(TokenDelimiter::BraceOpen) => Expr::Block(self.parse_expr_block()?),
+            Keyword(TokenKeyword::Loop) => Expr::Loop(self.parse_expr_loop()?),
+            Keyword(TokenKeyword::If) => Expr::If(self.parse_expr_if()?),
+            _ => {
+                self.error_expected_peek("expression");
+                return None;
+            }
+        })
+    }
+
+    /// exprUnary ::= [ unaryOp ] exprAtom
+    /// unaryOp   ::= "+" | "-" | "~"
+    fn parse_expr_unary(&mut self) -> Option<Expr> {
+        use TokenSymbol::*;
+        Some(match self.peek_token().kind {
+            TokenKind::Symbol(symbol @ (Minus | Plus | Tilde)) => {
+                self.next_token();
+                Expr::Op(symbol, Box::new(self.parse_expr_atom()?), None)
+            }
+            _ => self.parse_expr_atom()?,
+        })
+    }
+
+    /// exprArithmeticMul ::= exprUnary [ arithmeticMulOp exprArithmeticMul ]
+    /// arithmeticMulOp   ::= "*" | "/" | "%"
+    fn parse_expr_arithmetic_mul(&mut self) -> Option<Expr> {
+        use TokenSymbol::*;
+        let lhs = self.parse_expr_unary()?;
+
+        Some(match self.peek_token().kind {
+            TokenKind::Symbol(symbol @ (Star | Slash | Percent)) => {
+                self.next_token();
+                Expr::Op(
+                    symbol,
+                    Box::new(lhs),
+                    Some(Box::new(self.parse_expr_arithmetic_mul()?)),
+                )
+            }
+            _ => lhs,
+        })
+    }
+
+    /// exprArithmeticAdd ::= exprArithmeticMul [ arithmeticAddOp exprArithmeticAdd ]
+    /// arithmeticAddOp   ::= "+" | "-"
+    fn parse_expr_arithmetic_add(&mut self) -> Option<Expr> {
+        use TokenSymbol::*;
+        let lhs = self.parse_expr_arithmetic_mul()?;
+
+        Some(match self.peek_token().kind {
+            TokenKind::Symbol(symbol @ (Plus | Minus)) => {
+                self.next_token();
+                Expr::Op(
+                    symbol,
+                    Box::new(lhs),
+                    Some(Box::new(self.parse_expr_arithmetic_add()?)),
+                )
+            }
+            _ => lhs,
+        })
+    }
+
+    /// exprBitwiseShift ::= exprArithmeticAdd [ bitwiseShiftOp exprBitwiseShift ]
+    /// bitwiseShiftOp   ::= "<<" | ">>"
+    fn parse_expr_bitwise_shift(&mut self) -> Option<Expr> {
+        use TokenSymbol::*;
+        let lhs = self.parse_expr_arithmetic_add()?;
+
+        Some(match self.peek_token().kind {
+            TokenKind::Symbol(symbol @ (Shl | Shr)) => {
+                self.next_token();
+                Expr::Op(
+                    symbol,
+                    Box::new(lhs),
+                    Some(Box::new(self.parse_expr_bitwise_shift()?)),
+                )
+            }
+            _ => lhs,
+        })
+    }
+
+    /// exprBitwiseAnd ::= exprBitwiseShift [ "&" exprBitwiseAnd ]
+    fn parse_expr_bitwise_and(&mut self) -> Option<Expr> {
+        let lhs = self.parse_expr_bitwise_shift()?;
+        let symbol = TokenSymbol::And;
+
+        if !self.skip_token(TokenKind::Symbol(symbol)) {
+            return Some(lhs);
+        }
+
+        Some(Expr::Op(
+            symbol,
+            Box::new(lhs),
+            Some(Box::new(self.parse_expr_bitwise_and()?)),
+        ))
+    }
+
+    /// exprBitwiseXor ::= exprBitwiseAnd [ "^" exprBitwiseXor ]
+    fn parse_expr_bitwise_xor(&mut self) -> Option<Expr> {
+        let lhs = self.parse_expr_bitwise_and()?;
+        let symbol = TokenSymbol::Caret;
+
+        if !self.skip_token(TokenKind::Symbol(symbol)) {
+            return Some(lhs);
+        }
+
+        Some(Expr::Op(
+            symbol,
+            Box::new(lhs),
+            Some(Box::new(self.parse_expr_bitwise_xor()?)),
+        ))
+    }
+
+    /// exprBiwiseOr ::= exprBitwiseXor [ "|" exprBitwiseOr ]
+    fn parse_expr_bitwise_or(&mut self) -> Option<Expr> {
+        let lhs = self.parse_expr_bitwise_xor()?;
+        let symbol = TokenSymbol::Or;
+
+        if !self.skip_token(TokenKind::Symbol(symbol)) {
+            return Some(lhs);
+        }
+
+        Some(Expr::Op(
+            symbol,
+            Box::new(lhs),
+            Some(Box::new(self.parse_expr_bitwise_or()?)),
+        ))
+    }
+
+    /// exprAssign   ::= exprBitwiseOr [ relationalOp exprRelational ]
+    /// relationalOp ::= ">" | "<" | ">=" | "<=" | "==" | "!="
+    fn parse_expr_relational(&mut self) -> Option<Expr> {
+        use TokenSymbol::*;
+        let lhs = self.parse_expr_bitwise_or()?;
+
+        Some(match self.peek_token().kind {
+            TokenKind::Symbol(symbol @ (Gt | Lt | GtEq | LtEq | EqEq | Ne)) => {
+                self.next_token();
+                Expr::Op(
+                    symbol,
+                    Box::new(lhs),
+                    Some(Box::new(self.parse_expr_relational()?)),
+                )
+            }
+            _ => lhs,
+        })
+    }
+
+    /// exprLogicalAnd ::= exprLogicalRelational [ "&&" exprLogicalAnd ]
+    fn parse_expr_logical_and(&mut self) -> Option<Expr> {
+        let lhs = self.parse_expr_relational()?;
+        let symbol = TokenSymbol::AndAnd;
+
+        if !self.skip_token(TokenKind::Symbol(symbol)) {
+            return Some(lhs);
+        }
+
+        Some(Expr::Op(
+            symbol,
+            Box::new(lhs),
+            Some(Box::new(self.parse_expr_logical_and()?)),
+        ))
+    }
+
+    /// exprLogicalOr ::= exprLogicalAnd [ "||" exprLogicalOr ]
+    fn parse_expr_logical_or(&mut self) -> Option<Expr> {
+        let lhs = self.parse_expr_logical_and()?;
+        let symbol = TokenSymbol::OrOr;
+
+        if !self.skip_token(TokenKind::Symbol(symbol)) {
+            return Some(lhs);
+        }
+
+        Some(Expr::Op(
+            symbol,
+            Box::new(lhs),
+            Some(Box::new(self.parse_expr_logical_or()?)),
+        ))
+    }
+
+    /// exprAssign ::= exprLogicalOr [ assignOp exprAssign ]
+    /// assignOp   ::= "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "^=" | "<<=" | ">>=" | "&=" | "|="
+    fn parse_expr_assign(&mut self) -> Option<Expr> {
+        use TokenSymbol::*;
+        let lhs = self.parse_expr_logical_or()?;
+
+        Some(match self.peek_token().kind {
+            TokenKind::Symbol(
+                symbol @ (Eq | PlusEq | MinusEq | StarEq | SlashEq | PercentEq | CaretEq | ShlEq
+                | ShrEq | AndEq | OrEq),
+            ) => {
+                self.next_token();
+                Expr::Op(
+                    symbol,
+                    Box::new(lhs),
+                    Some(Box::new(self.parse_expr_assign()?)),
+                )
+            }
+            _ => lhs,
+        })
+    }
+
+    /// exprControl ::= "continue" | "break" | "return" [ exprControl ] | exprAssign
+    fn parse_expr_control(&mut self) -> Option<Expr> {
+        use TokenKeyword::*;
+
+        Some(match self.peek_token().kind {
+            TokenKind::Keyword(Continue) => {
+                self.next_token();
+                Expr::Continue
+            }
+            TokenKind::Keyword(Break) => {
+                self.next_token();
+                Expr::Break
+            }
+            TokenKind::Keyword(Return) => {
+                self.next_token();
+                Expr::Return(self.parse_expr_control().map(Box::new))
+            }
+            _ => self.parse_expr_assign()?,
+        })
+    }
+
+    /// entrypoint for expression parsing using recursive descent parsing
+    ///
+    /// <https://en.wikipedia.org/wiki/Recursive_descent_parser>
+    /// expr ::= exprControl
+    pub(super) fn parse_expr(&mut self) -> Option<Expr> {
+        self.parse_expr_control()
+    }
+}
+
+#[test]
+fn test_parse_expr() {
+    use Literal::*;
+    use TokenSymbol::*;
+
+    macro_rules! b {
+        ($expr:expr) => {
+            Box::new($expr)
+        };
+    }
+
+    let mut parser = Parser::new(
+        r#"if if 1 { 1 } else { 0 } + 9 {
+             a = 4
+           } else if 1 {
+             a = 5
+           } else {
+           }
+          amul ^= (4 + 93 * (1 << 3) / 1.44) ^ bhatura
+          stove = { 44 } + amul"#,
+    );
+
+    assert_eq!(
+        parser.parse_expr(),
+        Some(Expr::If(If {
+            cond: b!(Expr::Op(
+                Plus,
+                b!(Expr::If(If {
+                    cond: b!(Expr::Literal(Int(1))),
+                    then: vec![Statement::Expr(Expr::Literal(Int(1)))],
+                    or: Some(b!(ElseType::Else(vec![Statement::Expr(Expr::Literal(
+                        Int(0)
+                    ))])))
+                })),
+                Some(b!(Expr::Literal(Int(9))))
+            )),
+            then: vec![Statement::Expr(Expr::Op(
+                Eq,
+                b!(Expr::Identifier("a".into())),
+                Some(b!(Expr::Literal(Int(4))))
+            ))],
+            or: Some(b!(ElseType::If(If {
+                cond: b!(Expr::Literal(Int(1))),
+                then: vec![Statement::Expr(Expr::Op(
+                    Eq,
+                    b!(Expr::Identifier("a".into())),
+                    Some(b!(Expr::Literal(Int(5))))
+                ))],
+                or: Some(b!(ElseType::Else(vec![])))
+            })))
+        }))
+    );
+
+    assert_eq!(parser.skip_token(TokenKind::Newline), true);
+
+    assert_eq!(
+        parser.parse_expr(),
+        Some(Expr::Op(
+            CaretEq,
+            b!(Expr::Identifier("amul".into())),
+            Some(b!(Expr::Op(
+                Caret,
+                b!(Expr::Op(
+                    Plus,
+                    b!(Expr::Literal(Int(4))),
+                    Some(b!(Expr::Op(
+                        Star,
+                        b!(Expr::Literal(Int(93))),
+                        Some(b!(Expr::Op(
+                            Slash,
+                            b!(Expr::Op(
+                                Shl,
+                                b!(Expr::Literal(Int(1))),
+                                Some(b!(Expr::Literal(Int(3))))
+                            )),
+                            Some(b!(Expr::Literal(Float(1.44))))
+                        )))
+                    )))
+                )),
+                Some(b!(Expr::Identifier("bhatura".into())))
+            )))
+        ))
+    );
+
+    assert_eq!(parser.skip_token(TokenKind::Newline), true);
+
+    assert_eq!(
+        parser.parse_expr(),
+        Some(Expr::Op(
+            Eq,
+            b!(Expr::Identifier("stove".into())),
+            Some(b!(Expr::Op(
+                Plus,
+                b!(Expr::Block(vec![Statement::Expr(Expr::Literal(Int(44)))])),
+                Some(b!(Expr::Identifier("amul".into())))
+            )))
+        ))
+    );
+}

src/parser/literal.rs

@@ -0,0 +1,121 @@
+use super::Parser;
+use crate::lexer::{
+    TokenKind,
+    TokenLiteral,
+    TokenSymbol,
+};
+
+impl<'a> Parser<'a> {
+    /// int ::= digit { digit }
+    pub(super) fn parse_int(&mut self) -> Option<i32> {
+        let val = self.next_token().val;
+        let mut integer: i32 = 0;
+        let error = || {
+            self.error(&format!(
+                "integer values must be in range [{}, {}]",
+                i32::MIN,
+                i32::MAX
+            ))
+        };
+
+        for c in val.chars() {
+            // c is always ['0'..='9']
+            let d = c.to_digit(10)?;
+
+            match integer.checked_mul(10) {
+                Some(m) => integer = m,
+                None => {
+                    error();
+                    return None;
+                }
+            }
+
+            match integer.checked_add(d as i32) {
+                Some(a) => integer = a,
+                None => {
+                    error();
+                    return None;
+                }
+            }
+        }
+
+        Some(integer)
+    }
+
+    // didnt use parse() because i wanted to do this myself for some reason
+    /// f32 can be NaN and inf as well
+    /// float ::= int [ "." { digit } ] [ "e" { digit } ]
+    pub(super) fn parse_float(&mut self) -> Option<f32> {
+        let token = self.next_token();
+        let mut chars = token.val.chars();
+        let mut float: f32 = 0.0;
+        let mut fraction: f32 = 0.0;
+        let mut prec: i32 = 0;
+        let mut exp: i32 = 0;
+        let mut decimal: bool = false;
+
+        // lexer takes care of multiple decimals and non digit characters
+        for c in chars.by_ref() {
+            match c {
+                '.' => decimal = true,
+                'e' | 'E' => {
+                    // lexer takes care that decimal doesnt come after e
+                    let s;
+                    match self.peek_token().kind {
+                        TokenKind::Symbol(TokenSymbol::Minus) => {
+                            s = -1;
+                            self.next_token();
+                        }
+                        TokenKind::Symbol(TokenSymbol::Plus) => {
+                            s = 1;
+                            self.next_token();
+                        }
+                        _ => s = 1,
+                    }
+
+                    if self.peek_token().kind != TokenKind::Literal(TokenLiteral::Int) {
+                        break;
+                    }
+
+                    exp = self.parse_int()? * s;
+                    break;
+                }
+                _ => {
+                    // c is always ['0'..='9']
+                    let d = c.to_digit(10)? as f32;
+                    if decimal {
+                        fraction *= 10.0;
+                        fraction += d;
+                        prec += 1;
+                    } else {
+                        float *= 10.0;
+                        float += d;
+                    }
+                }
+            }
+        }
+
+        fraction /= 10f32.powi(prec);
+        float += fraction;
+        float *= 10f32.powi(exp);
+
+        Some(float)
+    }
+
+    /// char ::= "'" letter "'"
+    pub(super) fn parse_char(&mut self) -> Option<char> {
+        // the lexer ensures that the 0th and 2nd characters are both '
+        self.next_token().val.chars().nth(1)
+    }
+}
+
+#[test]
+fn test_parse_literals() {
+    let mut parser = Parser::new("4524 3123.15e4 9e2 9083482.429455 'c' 3331.13.1");
+    assert_eq!(parser.parse_int(), Some(4524));
+    assert_eq!(parser.parse_float(), Some(3123.15e4));
+    assert_eq!(parser.parse_float(), Some(9e2));
+    assert_eq!(parser.parse_float(), Some(9083482.429455));
+    assert_eq!(parser.parse_char(), Some('c'));
+    assert_eq!(parser.next_token().kind, TokenKind::Invalid);
+}

src/parser/mod.rs

@@ -0,0 +1,156 @@
+//! A naive parser just to get started
+//!
+//! Can only parse module, class and function declaration now along with let statements
+
+mod entity;
+mod expr;
+mod literal;
+mod statement;
+
+use crate::ast::{
+    Parent,
+    Ty,
+};
+use crate::lexer::{
+    Lexer,
+    Token,
+    TokenKeyword,
+    TokenKind,
+    TokenSymbol,
+};
+use std::rc::Rc;
+
+pub struct Parser<'a> {
+    pub lexer: Lexer<'a>,
+}
+
+impl<'a> Parser<'a> {
+    /// Creates a new [`Parser`] instance.
+    pub fn new(contents: &'a str) -> Parser<'a> {
+        Parser {
+            lexer: Lexer::new(contents),
+        }
+    }
+
+    #[inline]
+    fn error(&self, message: &str) {
+        eprintln!(
+            "Parser: {}, at \"{}:{}\"",
+            message, self.lexer.line, self.lexer.col
+        );
+    }
+
+    #[inline]
+    fn error_expected(&self, expected: &str, found: &str) {
+        self.error(&format!("expected {}, found {}", expected, found));
+    }
+
+    #[inline]
+    fn error_expected_peek(&mut self, expected: &str) {
+        let found = &Rc::clone(&self.peek_token().val);
+        self.error_expected(expected, found);
+    }
+
+    #[inline]
+    fn next_token(&mut self) -> Token {
+        let t = self.lexer.next_token();
+        println!("{:?}", t);
+        t
+    }
+
+    #[inline]
+    fn peek_token(&mut self) -> &Token {
+        return self.lexer.peek_token();
+    }
+
+    /// newline ::= "}\n"
+    fn trim_newlines(&mut self) {
+        while self.peek_token().kind == TokenKind::Newline {
+            self.next_token();
+        }
+    }
+
+    fn skip_token(&mut self, kind: TokenKind) -> bool {
+        if self.peek_token().kind == kind {
+            self.next_token();
+            return true;
+        }
+
+        false
+    }
+
+    fn check_newline_or_tok(&mut self, token: TokenKind) -> bool {
+        match self.peek_token().kind {
+            TokenKind::Newline => true,
+            d if d == token => true,
+            _ => false,
+        }
+    }
+
+    /// ty ::= "int" | "float" | "char"
+    fn parse_ty(&mut self) -> Option<Ty> {
+        let ty: Ty;
+
+        if let TokenKind::Keyword(keyword) = &self.peek_token().kind {
+            ty = match keyword {
+                TokenKeyword::Int => Ty::Int,
+                TokenKeyword::Char => Ty::Char,
+                TokenKeyword::Float => Ty::Float,
+                _ => {
+                    self.error_expected_peek("ty");
+                    return None;
+                }
+            };
+        } else {
+            self.error_expected_peek("ty");
+            return None;
+        }
+        self.next_token();
+        Some(ty)
+    }
+
+    /// ident ::= ( letter | "_" ) { letter | digit | "_" }
+    fn parse_ident(&mut self) -> Option<Rc<str>> {
+        if self.peek_token().kind != TokenKind::Identifier {
+            self.error_expected_peek("identifier");
+            return None;
+        }
+
+        Some(Rc::clone(&self.next_token().val))
+    }
+
+    /// identWithTy ::= letter ":" ty
+    fn parse_ident_with_ty(&mut self) -> Option<(Rc<str>, Ty)> {
+        let ident = self.parse_ident()?;
+
+        if !self.skip_token(TokenKind::Symbol(TokenSymbol::Colon)) {
+            self.error_expected_peek(":");
+            return None;
+        }
+
+        Some((ident, self.parse_ty()?))
+    }
+
+    /// Returns an [`Entity`] vector after parsing
+    ///
+    /// parent ::= { entity }
+    /// [`Entity`]: crate::ast::Entity
+    pub fn parse(&mut self) -> Option<Parent> {
+        let mut parent = vec![];
+
+        loop {
+            match self.peek_token().kind {
+                TokenKind::Newline => self.trim_newlines(),
+                TokenKind::Eof => break,
+                _ => {
+                    parent.push(self.parse_entity()?);
+                    if !self.check_newline_or_tok(TokenKind::Eof) {
+                        self.error_expected_peek("newline or end of file");
+                        return None;
+                    }
+                }
+            }
+        }
+        Some(parent)
+    }
+}

src/parser/statement.rs

@@ -0,0 +1,91 @@
+use super::Parser;
+use crate::ast::*;
+use crate::lexer::{
+    TokenKeyword,
+    TokenKind,
+    TokenSymbol,
+};
+
+impl<'a> Parser<'a> {
+    /// statement ::= static | let | expr
+    pub(super) fn parse_statement(&mut self) -> Option<Statement> {
+        use TokenKeyword::*;
+        println!("STMT");
+
+        Some(match self.peek_token().kind {
+            TokenKind::Keyword(Static) => Statement::Static(self.parse_static()?),
+            TokenKind::Keyword(Let) => Statement::Let(self.parse_let()?),
+            _ => Statement::Expr(self.parse_expr()?),
+        })
+    }
+
+    /// static ::="static" let
+    pub(super) fn parse_static(&mut self) -> Option<Let> {
+        self.next_token();
+
+        if self.peek_token().kind != TokenKind::Keyword(TokenKeyword::Let) {
+            self.error_expected_peek("let");
+            return None;
+        }
+
+        self.parse_let()
+    }
+
+    /// let ::= "let" identWithTy "=" expr
+    pub(super) fn parse_let(&mut self) -> Option<Let> {
+        self.next_token();
+
+        let (name, ty) = self.parse_ident_with_ty()?;
+
+        let expr = if self.skip_token(TokenKind::Symbol(TokenSymbol::Eq)) {
+            self.parse_expr()
+        } else if self.peek_token().kind == TokenKind::Newline {
+            None
+        } else {
+            self.error_expected_peek("= or newline");
+            return None;
+        };
+
+        Some(Let { name, ty, expr })
+    }
+}
+
+#[test]
+fn test_parse_let() {
+    use Literal::*;
+
+    let mut parser = Parser::new(
+        r#"static let test01: int = 4
+           let test02: char = '6'
+           static let test03: float
+           let test04 = 9"#,
+    );
+    assert_eq!(
+        parser.parse_static(),
+        Some(Let {
+            name: "test01".into(),
+            ty: Ty::Int,
+            expr: Some(Expr::Literal(Int(4)))
+        })
+    );
+    assert_eq!(parser.skip_token(TokenKind::Newline), true);
+    assert_eq!(
+        parser.parse_let(),
+        Some(Let {
+            name: "test02".into(),
+            ty: Ty::Char,
+            expr: Some(Expr::Literal(Char('6')))
+        })
+    );
+    assert_eq!(parser.skip_token(TokenKind::Newline), true);
+    assert_eq!(
+        parser.parse_static(),
+        Some(Let {
+            name: "test03".into(),
+            ty: Ty::Float,
+            expr: None
+        })
+    );
+    assert_eq!(parser.skip_token(TokenKind::Newline), true);
+    assert_eq!(parser.parse_let(), None);
+}