diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml
new file mode 100644
index 00000000..0f90f608
--- /dev/null
+++ b/.github/workflows/codecov.yml
@@ -0,0 +1,22 @@
+name: Coverage
+
+on: [pull_request, push]
+
+jobs:
+  coverage:
+    runs-on: ubuntu-latest
+    env:
+      CARGO_TERM_COLOR: always
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Rust
+        run: rustup update stable
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
+      - name: Generate code coverage
+        run: cargo llvm-cov --all-features --workspace --lcov --output-path lcov.info
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v3
+        with:
+          files: lcov.info
+          fail_ci_if_error: true
\ No newline at end of file
diff --git a/README.md b/README.md
index 3181714a..87ed232b 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,17 @@
 # λykiaDB
+<div style="display: flex;">
+<div>
+
 [![CI](https://github.com/lykia-rs/lykiadb/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/lykia-rs/lykiadb/actions/workflows/ci.yml)
 
+</div>
+<div>
+
+[![codecov](https://codecov.io/gh/lykia-rs/lykiadb/graph/badge.svg?token=DGIK7BE3K1)](https://codecov.io/gh/lykia-rs/lykiadb)
+
+</div>
+</div>
+
 <p align="center">
     <img alt="LykiaDB logo" height="200" src="https://vcankeklik.com/assets/img/logo.svg?v=051223">
 </p>
diff --git a/server/benches/scripts/fib.ly b/server/benches/scripts/fib.ly
index ead6f524..78781219 100644
--- a/server/benches/scripts/fib.ly
+++ b/server/benches/scripts/fib.ly
@@ -1,5 +1,5 @@
 // Define recursive Fibonacci function
-fun fib($n) {
+function fib($n) {
   if ($n < 2) return $n;
   return fib($n - 2) + fib($n - 1);
 }
diff --git a/server/benches/scripts/while.ly b/server/benches/scripts/while.ly
index 8984f421..389a92e0 100644
--- a/server/benches/scripts/while.ly
+++ b/server/benches/scripts/while.ly
@@ -10,7 +10,6 @@ while ($i < 10000000) {
 }
 
 $i = 0;
-
 while ($i < 10000000) {
   $i = $i + 1;
 
@@ -18,4 +17,4 @@ while ($i < 10000000) {
   null == null; null == 1; null == "str"; null == true;
   true == true; true == 1; true == false; true == "str"; true == null;
   "str" == "str"; "str" == "stru"; "str" == 1; "str" == null; "str" == true;
-}
\ No newline at end of file
+}
diff --git a/server/examples/fib.ly b/server/examples/fib.ly
index e9ae733c..ddeae2db 100644
--- a/server/examples/fib.ly
+++ b/server/examples/fib.ly
@@ -1,5 +1,5 @@
 // Define recursive Fibonacci function
-fun fib($n) {
+function fib($n) {
   if ($n < 2) return $n;
   return fib($n - 2) + fib($n - 1);
 };
diff --git a/server/examples/fn.ly b/server/examples/fn.ly
index 43a65694..90f2177e 100644
--- a/server/examples/fn.ly
+++ b/server/examples/fn.ly
@@ -1,4 +1,4 @@
-fun helloWorld ($message) {
+function helloWorld ($message) {
     print("Hello world!", $message);
     {
         {
diff --git a/server/examples/scan_err.ly b/server/examples/scan_err.ly
index 0c72e47c..abfe9c87 100644
--- a/server/examples/scan_err.ly
+++ b/server/examples/scan_err.ly
@@ -1,5 +1,5 @@
 // Define recursive Fibonacci function
-fun fib($n) {
+function fib($n) {
   if ($n < 2) return $n;
   return fib($n - 2) + fib($n - 1);
 };
diff --git a/server/src/lang/ast/sql.rs b/server/src/lang/ast/sql.rs
index 85aea957..f600fe2d 100644
--- a/server/src/lang/ast/sql.rs
+++ b/server/src/lang/ast/sql.rs
@@ -39,39 +39,30 @@ pub enum SqlExpr {
     Default(ExprId),
 }
 
-#[derive(Debug, Eq, PartialEq)]
-pub enum SqlFrom {
-    CollectionSubquery(Vec<SqlCollectionSubquery>),
-    JoinClause(Box<SqlJoinClause>),
-}
-
 #[derive(Debug, Eq, PartialEq)]
 pub enum SqlProjection {
-    All,
-    /*AllFieldsOf{
-        collection: Token
-    },*/
-    Complex { expr: SqlExpr, alias: Option<Token> },
+    All { collection: Option<Token> },
+    Expr { expr: SqlExpr, alias: Option<Token> },
 }
 
 #[derive(Debug, Eq, PartialEq)]
-pub enum SqlJoinClause {
-    None(SqlCollectionSubquery),
-    Join(Vec<(SqlJoinType, SqlCollectionSubquery, SqlExpr)>),
+pub struct SqlJoin {
+    pub join_type: SqlJoinType,
+    pub subquery: SqlCollectionSubquery,
+    pub join_constraint: Option<SqlExpr>,
 }
 
 #[derive(Debug, Eq, PartialEq)]
 pub enum SqlCollectionSubquery {
-    Simple {
+    Group(Vec<SqlCollectionSubquery>),
+    Join(Box<SqlCollectionSubquery>, Vec<SqlJoin>),
+    Collection {
         namespace: Option<Token>,
-        collection: Token,
+        name: Token,
         alias: Option<Token>,
     },
-    From {
-        from: SqlFrom,
-    },
     Select {
-        stmt: SqlSelect,
+        expr: ExprId,
         alias: Option<Token>,
     },
 }
@@ -80,7 +71,7 @@ pub enum SqlCollectionSubquery {
 pub struct SelectCore {
     pub distinct: SqlDistinct,
     pub projection: Vec<SqlProjection>,
-    pub from: Option<SqlFrom>,
+    pub from: Option<SqlCollectionSubquery>,
     pub r#where: Option<SqlExpr>,
     pub group_by: Option<Vec<SqlExpr>>,
     pub having: Option<SqlExpr>,
diff --git a/server/src/lang/parser.rs b/server/src/lang/parser.rs
index d0675259..e1af48f7 100644
--- a/server/src/lang/parser.rs
+++ b/server/src/lang/parser.rs
@@ -1,7 +1,7 @@
 use super::ast::expr::{Expr, ExprId};
 use super::ast::sql::{
-    SelectCore, SqlCollectionSubquery, SqlCompoundOperator, SqlDistinct, SqlExpr, SqlFrom,
-    SqlOrdering, SqlProjection, SqlSelect,
+    SelectCore, SqlCollectionSubquery, SqlCompoundOperator, SqlDistinct, SqlExpr, SqlJoin,
+    SqlJoinType, SqlOrdering, SqlProjection, SqlSelect,
 };
 use super::ast::stmt::{Stmt, StmtId};
 use super::ast::{Literal, ParserArena};
@@ -42,7 +42,7 @@ type ParseResult<T> = Result<T, ParseError>;
 macro_rules! binary {
     ($self: ident, [$($operator:expr),*], $builder: ident) => {
         let mut current_expr: ExprId = $self.$builder()?;
-        while $self.match_next_multi(&vec![$($operator,)*]) {
+        while $self.match_next_one_of(&vec![$($operator,)*]) {
             let token = (*$self.peek_bw(1)).clone();
             let left = current_expr;
             let right = $self.$builder()?;
@@ -460,7 +460,7 @@ impl<'a> Parser<'a> {
     }
 
     fn unary(&mut self) -> ParseResult<ExprId> {
-        if self.match_next_multi(&vec![sym!(Minus), sym!(Bang)]) {
+        if self.match_next_one_of(&vec![sym!(Minus), sym!(Bang)]) {
             let token = (*self.peek_bw(1)).clone();
             let unary = self.unary()?;
             return Ok(self.arena.expression(Expr::Unary {
@@ -470,16 +470,16 @@ impl<'a> Parser<'a> {
                     .get_merged_span(&token.span, &self.arena.get_expression(unary).get_span()),
             }));
         }
-        self.select()
+        self.sql_select()
     }
 
-    fn select(&mut self) -> ParseResult<ExprId> {
+    fn sql_select(&mut self) -> ParseResult<ExprId> {
         if !self.cmp_tok(&skw!(Select)) {
             return self.call();
         }
-        let core = self.select_core()?;
+        let core = self.sql_select_core()?;
         let mut compounds: Vec<(SqlCompoundOperator, SelectCore)> = vec![];
-        while self.match_next_multi(&vec![skw!(Union), skw!(Intersect), skw!(Except)]) {
+        while self.match_next_one_of(&vec![skw!(Union), skw!(Intersect), skw!(Except)]) {
             let op = self.peek_bw(1);
             let compound_op = if op.tok_type == skw!(Union) && self.match_next(skw!(All)) {
                 SqlCompoundOperator::UnionAll
@@ -493,7 +493,7 @@ impl<'a> Parser<'a> {
                     }
                 }
             };
-            let secondary_core = self.select_core()?;
+            let secondary_core = self.sql_select_core()?;
             compounds.push((compound_op, secondary_core))
         }
         let order_by = if self.match_next(skw!(Order)) {
@@ -548,21 +548,20 @@ impl<'a> Parser<'a> {
         }))
     }
 
-    fn select_core(&mut self) -> ParseResult<SelectCore> {
+    fn sql_select_core(&mut self) -> ParseResult<SelectCore> {
         self.expected(skw!(Select))?;
         let distinct = if self.match_next(skw!(Distinct)) {
             SqlDistinct::Distinct
+        } else if self.match_next(skw!(All)) {
+            SqlDistinct::All
         } else {
             SqlDistinct::All
         };
-        /* else if self.match_next(skw!(All)) {
-            SqlDistinct::All
-        }*/
 
-        let projection = self.sql_projection();
-        let from = self.sql_from()?;
-        let r#where = self.sql_where()?;
-        let group_by = self.sql_group_by()?;
+        let projection = self.sql_select_projection();
+        let from = self.sql_select_from()?;
+        let r#where = self.sql_select_where()?;
+        let group_by = self.sql_select_group_by()?;
         let having = if group_by.is_some() && self.match_next(skw!(Having)) {
             Some(SqlExpr::Default(self.expression()?))
         } else {
@@ -579,7 +578,7 @@ impl<'a> Parser<'a> {
         })
     }
 
-    fn sql_group_by(&mut self) -> ParseResult<Option<Vec<SqlExpr>>> {
+    fn sql_select_group_by(&mut self) -> ParseResult<Option<Vec<SqlExpr>>> {
         if self.match_next(skw!(Group)) {
             self.expected(skw!(By))?;
             let mut groups: Vec<SqlExpr> = vec![];
@@ -597,16 +596,24 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn sql_projection(&mut self) -> Vec<SqlProjection> {
+    fn sql_select_projection(&mut self) -> Vec<SqlProjection> {
         let mut projections: Vec<SqlProjection> = vec![];
         loop {
             if self.match_next(sym!(Star)) {
-                projections.push(SqlProjection::All);
+                projections.push(SqlProjection::All { collection: None });
+            } else if self.match_next_all_of(&vec![
+                Identifier { dollar: false },
+                sym!(Dot),
+                sym!(Star),
+            ]) {
+                projections.push(SqlProjection::All {
+                    collection: Some(self.peek_bw(3).clone()),
+                });
             } else {
                 let expr = self.expression().unwrap();
                 let alias: Option<Token> =
                     optional_with_expected!(self, skw!(As), Identifier { dollar: false });
-                projections.push(SqlProjection::Complex {
+                projections.push(SqlProjection::Expr {
                     expr: SqlExpr::Default(expr),
                     alias,
                 });
@@ -615,26 +622,109 @@ impl<'a> Parser<'a> {
                 break;
             }
         }
-        // TODO(vck): Add support for collection selectors
         projections
     }
 
-    fn sql_from(&mut self) -> ParseResult<Option<SqlFrom>> {
+    fn sql_select_from(&mut self) -> ParseResult<Option<SqlCollectionSubquery>> {
         if self.match_next(skw!(From)) {
-            let token = self.expected(Identifier { dollar: false });
-            return Ok(Some(SqlFrom::CollectionSubquery(vec![
-                SqlCollectionSubquery::Simple {
-                    namespace: None,
-                    collection: token.unwrap().clone(),
-                    alias: None,
-                },
-            ])));
-        }
-        // TODO(vck): Joins
+            return Ok(Some(self.sql_select_subquery_join()?));
+        }
         Ok(None)
     }
 
-    fn sql_where(&mut self) -> ParseResult<Option<SqlExpr>> {
+    fn sql_select_subquery_join(&mut self) -> ParseResult<SqlCollectionSubquery> {
+        let mut subquery_group: Vec<SqlCollectionSubquery> = vec![];
+
+        loop {
+            let subquery = self.sql_select_subquery_collection()?;
+            subquery_group.push(subquery);
+            if !self.match_next(sym!(Comma)) {
+                break;
+            }
+        }
+
+        let mut joins: Vec<SqlJoin> = vec![];
+
+        while self.match_next_one_of(&vec![skw!(Left), skw!(Right), skw!(Inner), skw!(Join)]) {
+            // If the next token is a join keyword, then it must be a join subquery
+            let peek = self.peek_bw(1);
+            let join_type = if peek.tok_type == skw!(Inner) {
+                self.expected(skw!(Join))?;
+                SqlJoinType::Inner
+            } else if peek.tok_type == skw!(Left) {
+                optional_with_expected!(self, skw!(Outer), skw!(Join));
+                SqlJoinType::Left
+            } else if peek.tok_type == skw!(Right) {
+                optional_with_expected!(self, skw!(Outer), skw!(Join));
+                SqlJoinType::Right
+            } else if peek.tok_type == skw!(Join) {
+                SqlJoinType::Inner
+            } else {
+                return Err(ParseError::UnexpectedToken {
+                    token: peek.clone(),
+                });
+            };
+            let subquery = self.sql_select_subquery_collection()?;
+            let mut join_constraint: Option<SqlExpr> = None;
+            if self.match_next(skw!(On)) {
+                join_constraint = Some(SqlExpr::Default(self.expression()?));
+            }
+            joins.push(SqlJoin {
+                join_type,
+                subquery,
+                join_constraint,
+            });
+        }
+
+        if !joins.is_empty() {
+            return Ok(SqlCollectionSubquery::Join(
+                Box::new(SqlCollectionSubquery::Group(subquery_group)),
+                joins,
+            ));
+        }
+
+        return Ok(SqlCollectionSubquery::Group(subquery_group));
+    }
+
+    fn sql_select_subquery_collection(&mut self) -> ParseResult<SqlCollectionSubquery> {
+        if self.match_next(sym!(LeftParen)) {
+            if self.cmp_tok(&skw!(Select)) {
+                let expr = self.sql_select()?;
+                self.expected(sym!(RightParen))?; // closing paren
+                let alias: Option<Token> =
+                    optional_with_expected!(self, skw!(As), Identifier { dollar: false });
+                return Ok(SqlCollectionSubquery::Select { expr, alias });
+            }
+            // If the next token is a left paren, then it must be either a select statement or a recursive subquery
+            let parsed = self.sql_select_subquery_join()?; // TODO(vck): Check if using _collection variant makes sense.
+            self.expected(sym!(RightParen))?; // closing paren
+            return Ok(parsed);
+        } else if self.cmp_tok(&Identifier { dollar: false }) {
+            // If the next token is not a left paren, then it must be a collection getter
+            if self.match_next_all_of(&vec![
+                Identifier { dollar: false },
+                sym!(Dot),
+                Identifier { dollar: false },
+            ]) {
+                return Ok(SqlCollectionSubquery::Collection {
+                    namespace: Some(self.peek_bw(3).clone()),
+                    name: self.peek_bw(1).clone(),
+                    alias: optional_with_expected!(self, skw!(As), Identifier { dollar: false }),
+                });
+            }
+            return Ok(SqlCollectionSubquery::Collection {
+                namespace: None,
+                name: self.expected(Identifier { dollar: false })?.clone(),
+                alias: optional_with_expected!(self, skw!(As), Identifier { dollar: false }),
+            });
+        } else {
+            Err(ParseError::UnexpectedToken {
+                token: self.peek_bw(0).clone(),
+            })
+        }
+    }
+
+    fn sql_select_where(&mut self) -> ParseResult<Option<SqlExpr>> {
         if self.match_next(skw!(Where)) {
             let expr = self.expression()?;
             return Ok(Some(SqlExpr::Default(expr)));
@@ -789,6 +879,10 @@ impl<'a> Parser<'a> {
         &self.tokens[self.current - offset]
     }
 
+    fn peek_fw(&self, offset: usize) -> &'a Token {
+        &self.tokens[self.current + offset]
+    }
+
     fn cmp_tok(&self, t: &TokenType) -> bool {
         let current = self.peek_bw(0);
         current.tok_type == *t
@@ -802,8 +896,20 @@ impl<'a> Parser<'a> {
         false
     }
 
-    fn match_next_multi(&mut self, types: &Vec<TokenType>) -> bool {
-        for t in types {
+    fn match_next_all_of(&mut self, tokens: &Vec<TokenType>) -> bool {
+        for (i, t) in tokens.iter().enumerate() {
+            if self.peek_fw(i).tok_type != *t {
+                return false;
+            }
+        }
+        for _ in 0..tokens.len() {
+            self.advance();
+        }
+        return true;
+    }
+
+    fn match_next_one_of(&mut self, tokens: &Vec<TokenType>) -> bool {
+        for t in tokens {
             if self.cmp_tok(t) {
                 self.advance();
                 return true;
@@ -821,191 +927,7 @@ impl<'a> Parser<'a> {
 
 #[cfg(test)]
 mod test {
+    use crate::parse_tests;
 
-    use assert_json_diff::assert_json_eq;
-    use serde_json::{json, Value};
-
-    use crate::lang::{scanner::Scanner, token::Token};
-
-    use super::*;
-
-    fn get_tokens(source: &str) -> Vec<Token> {
-        return Scanner::scan(source).unwrap();
-    }
-
-    fn compare_parsed_to_expected(source: &str, expected: Value) {
-        let tokens = get_tokens(source);
-        let mut parsed = Parser::parse(&tokens).unwrap();
-        let actual = parsed.to_json();
-        assert_json_eq!(actual, expected);
-    }
-
-    #[test]
-    fn test_parse_literal_expression() {
-        compare_parsed_to_expected(
-            "1;",
-            json!({
-                "type": "Stmt::Program",
-                "body": [
-                    {
-                        "type": "Stmt::Expression",
-                        "value": {
-                            "type": "Expr::Literal",
-                            "value": "Num(1.0)",
-                            "raw": "1"
-                        }
-                    }
-                ]
-            }),
-        );
-    }
-
-    #[test]
-    fn test_parse_unary_expression() {
-        compare_parsed_to_expected(
-            "-1;",
-            json!({
-                "type": "Stmt::Program",
-                "body": [
-                    {
-                        "type": "Stmt::Expression",
-                        "value": {
-                            "type": "Expr::Unary",
-                            "operator": {
-                                "Symbol": "Minus"
-                            },
-                            "value": {
-                                "type": "Expr::Literal",
-                                "value": "Num(1.0)",
-                                "raw": "1"
-                            }
-                        }
-                    }
-                ]
-            }),
-        );
-    }
-
-    #[test]
-    fn test_parse_binary_expression() {
-        compare_parsed_to_expected(
-            "1 + 2;",
-            json!({
-                "type": "Stmt::Program",
-                "body": [
-                    {
-                        "type": "Stmt::Expression",
-                        "value": {
-                            "type": "Expr::Binary",
-                            "left": {
-                                "type": "Expr::Literal",
-                                "value": "Num(1.0)",
-                                "raw": "1"
-                            },
-                            "operator": {
-                                "Symbol": "Plus"
-                            },
-                            "right": {
-                                "type": "Expr::Literal",
-                                "value": "Num(2.0)",
-                                "raw": "2"
-                            }
-                        }
-                    }
-                ]
-            }),
-        );
-    }
-
-    #[test]
-    fn test_parse_grouping_expression() {
-        compare_parsed_to_expected(
-            "(1 + 2) * (3 / (4 - 7));",
-            json!({
-                "type": "Stmt::Program",
-                "body": [
-                    {
-                        "type": "Stmt::Expression",
-                        "value": {
-                            "type": "Expr::Binary",
-                            "left": {
-                                "type": "Expr::Grouping",
-                                "value": {
-                                    "type": "Expr::Binary",
-                                    "left": {
-                                        "raw": "1",
-                                        "type": "Expr::Literal",
-                                        "value": "Num(1.0)",
-                                    },
-                                    "operator": {
-                                        "Symbol": "Plus"
-                                    },
-                                    "right": {
-                                        "raw": "2",
-                                        "type": "Expr::Literal",
-                                        "value": "Num(2.0)",
-                                    }
-                                }
-                            },
-                            "operator": {
-                                "Symbol": "Star"
-                            },
-                            "right": {
-                                "type": "Expr::Grouping",
-                                "value": {
-                                    "type": "Expr::Binary",
-                                    "left": {
-                                        "raw": "3",
-                                        "type": "Expr::Literal",
-                                        "value": "Num(3.0)",
-                                    },
-                                    "operator": {
-                                        "Symbol": "Slash"
-                                    },
-                                    "right": {
-                                        "type": "Expr::Grouping",
-                                        "value": {
-                                            "type": "Expr::Binary",
-                                            "left": {
-                                                "raw": "4",
-                                                "type": "Expr::Literal",
-                                                "value": "Num(4.0)",
-                                            },
-                                            "operator":  {
-                                                "Symbol": "Minus"
-                                            },
-                                            "right": {
-                                                "raw": "7",
-                                                "type": "Expr::Literal",
-                                                "value": "Num(7.0)",
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                ]
-            }),
-        );
-    }
-
-    #[test]
-    fn test_parse_variable_expression() {
-        compare_parsed_to_expected(
-            "$a;",
-            json!({
-                "type": "Stmt::Program",
-                "body": [
-                    {
-                        "type": "Stmt::Expression",
-                        "value": {
-                            "type": "Expr::Variable",
-                            "value": "$a",
-                        }
-                    }
-                ]
-            }),
-        );
-    }
+    parse_tests!(generic / binary, unary, grouping, number_literal, variable, function_call);
 }
diff --git a/server/src/lang/scanner.rs b/server/src/lang/scanner.rs
index 2f0f21bd..bb777e30 100644
--- a/server/src/lang/scanner.rs
+++ b/server/src/lang/scanner.rs
@@ -830,7 +830,7 @@ mod test {
     #[test]
     fn test_keywords() {
         assert_tokens(
-            "and or class else for fun if break continue return super this var while loop",
+            "and or class else for function if break continue return super this var while loop",
             vec![
                 Token {
                     tok_type: kw!(Keyword::And),
@@ -889,12 +889,12 @@ mod test {
                 },
                 Token {
                     tok_type: kw!(Keyword::Fun),
-                    lexeme: lexm!("fun"),
+                    lexeme: lexm!("function"),
                     literal: None,
                     span: Span {
                         line: 0,
                         start: 22,
-                        end: 25,
+                        end: 30,
                         line_end: 0,
                     },
                 },
@@ -904,8 +904,8 @@ mod test {
                     literal: None,
                     span: Span {
                         line: 0,
-                        start: 26,
-                        end: 28,
+                        start: 31,
+                        end: 33,
                         line_end: 0,
                     },
                 },
@@ -915,8 +915,8 @@ mod test {
                     literal: None,
                     span: Span {
                         line: 0,
-                        start: 29,
-                        end: 34,
+                        start: 34,
+                        end: 39,
                         line_end: 0,
                     },
                 },
@@ -926,8 +926,8 @@ mod test {
                     literal: None,
                     span: Span {
                         line: 0,
-                        start: 35,
-                        end: 43,
+                        start: 40,
+                        end: 48,
                         line_end: 0,
                     },
                 },
@@ -937,8 +937,8 @@ mod test {
                     literal: None,
                     span: Span {
                         line: 0,
-                        start: 44,
-                        end: 50,
+                        start: 49,
+                        end: 55,
                         line_end: 0,
                     },
                 },
@@ -948,8 +948,8 @@ mod test {
                     literal: None,
                     span: Span {
                         line: 0,
-                        start: 51,
-                        end: 56,
+                        start: 56,
+                        end: 61,
                         line_end: 0,
                     },
                 },
@@ -959,8 +959,8 @@ mod test {
                     literal: None,
                     span: Span {
                         line: 0,
-                        start: 57,
-                        end: 61,
+                        start: 62,
+                        end: 66,
                         line_end: 0,
                     },
                 },
@@ -970,8 +970,8 @@ mod test {
                     literal: None,
                     span: Span {
                         line: 0,
-                        start: 62,
-                        end: 65,
+                        start: 67,
+                        end: 70,
                         line_end: 0,
                     },
                 },
@@ -981,8 +981,8 @@ mod test {
                     literal: None,
                     span: Span {
                         line: 0,
-                        start: 66,
-                        end: 71,
+                        start: 71,
+                        end: 76,
                         line_end: 0,
                     },
                 },
@@ -992,8 +992,8 @@ mod test {
                     literal: None,
                     span: Span {
                         line: 0,
-                        start: 72,
-                        end: 76,
+                        start: 77,
+                        end: 81,
                         line_end: 0,
                     },
                 },
@@ -1003,8 +1003,8 @@ mod test {
                     literal: None,
                     span: Span {
                         line: 0,
-                        start: 77,
-                        end: 77,
+                        start: 82,
+                        end: 82,
                         line_end: 0,
                     },
                 },
diff --git a/server/src/lang/serializer.rs b/server/src/lang/serializer.rs
index 05bdff02..b19a9199 100644
--- a/server/src/lang/serializer.rs
+++ b/server/src/lang/serializer.rs
@@ -30,7 +30,11 @@ impl Visitor<Value, ()> for Parsed {
                 "type": "Expr::Select",
                 // TODO(vck): Implement rest of the select
             }),
-            Expr::Literal { raw, span: _, value } => {
+            Expr::Literal {
+                raw,
+                span: _,
+                value,
+            } => {
                 json!({
                     "type": "Expr::Literal",
                     "value": format!("{:?}", value),
@@ -43,7 +47,11 @@ impl Visitor<Value, ()> for Parsed {
                     "value": self.visit_expr(*expr)?,
                 })
             }
-            Expr::Unary { symbol, expr, span: _ } => {
+            Expr::Unary {
+                symbol,
+                expr,
+                span: _,
+            } => {
                 json!({
                     "type": "Expr::Unary",
                     "operator": symbol,
@@ -89,7 +97,11 @@ impl Visitor<Value, ()> for Parsed {
                     "right": self.visit_expr(*right)?,
                 })
             }
-            Expr::Call { callee, span: _, args } => {
+            Expr::Call {
+                callee,
+                span: _,
+                args,
+            } => {
                 json!({
                     "type": "Expr::Call",
                     "callee": self.visit_expr(*callee)?,
diff --git a/server/src/lang/tests/generic/binary.json b/server/src/lang/tests/generic/binary.json
new file mode 100644
index 00000000..7f2e2dfb
--- /dev/null
+++ b/server/src/lang/tests/generic/binary.json
@@ -0,0 +1,27 @@
+{
+    "source": "1 + 2;",
+    "expected": {
+        "type": "Stmt::Program",
+        "body": [
+            {
+                "type": "Stmt::Expression",
+                "value": {
+                    "type": "Expr::Binary",
+                    "left": {
+                        "type": "Expr::Literal",
+                        "value": "Num(1.0)",
+                        "raw": "1"
+                    },
+                    "operator": {
+                        "Symbol": "Plus"
+                    },
+                    "right": {
+                        "type": "Expr::Literal",
+                        "value": "Num(2.0)",
+                        "raw": "2"
+                    }
+                }
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/server/src/lang/tests/generic/function_call.json b/server/src/lang/tests/generic/function_call.json
new file mode 100644
index 00000000..82d7f350
--- /dev/null
+++ b/server/src/lang/tests/generic/function_call.json
@@ -0,0 +1,25 @@
+{
+    "source": "print(50);",
+    "expected": {
+        "type": "Stmt::Program",
+        "body": [
+            {
+                "type": "Stmt::Expression",
+                "value": {
+                    "type": "Expr::Call",
+                    "callee": {
+                        "type": "Expr::Variable",
+                        "value": "print"
+                    },
+                    "args": [
+                        {
+                            "type": "Expr::Literal",
+                            "value": "Num(50.0)",
+                            "raw": "50"
+                        }
+                    ]
+                }
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/server/src/lang/tests/generic/grouping.json b/server/src/lang/tests/generic/grouping.json
new file mode 100644
index 00000000..f219d0ec
--- /dev/null
+++ b/server/src/lang/tests/generic/grouping.json
@@ -0,0 +1,69 @@
+{
+    "source": "(1 + 2) * (3 / (4 - 7));",
+    "expected": {
+        "type": "Stmt::Program",
+        "body": [
+            {
+                "type": "Stmt::Expression",
+                "value": {
+                    "type": "Expr::Binary",
+                    "left": {
+                        "type": "Expr::Grouping",
+                        "value": {
+                            "type": "Expr::Binary",
+                            "left": {
+                                "raw": "1",
+                                "type": "Expr::Literal",
+                                "value": "Num(1.0)"
+                            },
+                            "operator": {
+                                "Symbol": "Plus"
+                            },
+                            "right": {
+                                "raw": "2",
+                                "type": "Expr::Literal",
+                                "value": "Num(2.0)"
+                            }
+                        }
+                    },
+                    "operator": {
+                        "Symbol": "Star"
+                    },
+                    "right": {
+                        "type": "Expr::Grouping",
+                        "value": {
+                            "type": "Expr::Binary",
+                            "left": {
+                                "raw": "3",
+                                "type": "Expr::Literal",
+                                "value": "Num(3.0)"
+                            },
+                            "operator": {
+                                "Symbol": "Slash"
+                            },
+                            "right": {
+                                "type": "Expr::Grouping",
+                                "value": {
+                                    "type": "Expr::Binary",
+                                    "left": {
+                                        "raw": "4",
+                                        "type": "Expr::Literal",
+                                        "value": "Num(4.0)"
+                                    },
+                                    "operator":  {
+                                        "Symbol": "Minus"
+                                    },
+                                    "right": {
+                                        "raw": "7",
+                                        "type": "Expr::Literal",
+                                        "value": "Num(7.0)"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/server/src/lang/tests/generic/number_literal.json b/server/src/lang/tests/generic/number_literal.json
new file mode 100644
index 00000000..e567643f
--- /dev/null
+++ b/server/src/lang/tests/generic/number_literal.json
@@ -0,0 +1,16 @@
+{
+    "source": "1;",
+    "expected": {
+        "type": "Stmt::Program",
+        "body": [
+            {
+                "type": "Stmt::Expression",
+                "value": {
+                    "type": "Expr::Literal",
+                    "value": "Num(1.0)",
+                    "raw": "1"
+                }
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/server/src/lang/tests/generic/unary.json b/server/src/lang/tests/generic/unary.json
new file mode 100644
index 00000000..4c613844
--- /dev/null
+++ b/server/src/lang/tests/generic/unary.json
@@ -0,0 +1,22 @@
+{
+    "source": "-1;",
+    "expected": {
+        "type": "Stmt::Program",
+        "body": [
+            {
+                "type": "Stmt::Expression",
+                "value": {
+                    "type": "Expr::Unary",
+                    "operator": {
+                        "Symbol": "Minus"
+                    },
+                    "value": {
+                        "type": "Expr::Literal",
+                        "value": "Num(1.0)",
+                        "raw": "1"
+                    }
+                }
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/server/src/lang/tests/generic/variable.json b/server/src/lang/tests/generic/variable.json
new file mode 100644
index 00000000..e05b6e94
--- /dev/null
+++ b/server/src/lang/tests/generic/variable.json
@@ -0,0 +1,15 @@
+{
+    "source": "$a;",
+    "expected": {
+        "type": "Stmt::Program",
+        "body": [
+            {
+                "type": "Stmt::Expression",
+                "value": {
+                    "type": "Expr::Variable",
+                    "value": "$a"
+                }
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/server/src/lang/tests/helpers.rs b/server/src/lang/tests/helpers.rs
index 2f3a2581..cfa9334c 100644
--- a/server/src/lang/tests/helpers.rs
+++ b/server/src/lang/tests/helpers.rs
@@ -1,6 +1,63 @@
+#[cfg(test)]
+use assert_json_diff::assert_json_eq;
+
+#[cfg(test)]
+use serde_json::Value;
+
+#[cfg(test)]
+use crate::lang::{parser::Parser, scanner::Scanner, token::Token};
+
 #[macro_export]
 macro_rules! lexm {
     ($a: literal) => {
         Some($a.to_owned())
     };
 }
+
+#[cfg(test)]
+pub fn get_tokens(source: &str) -> Vec<Token> {
+    return Scanner::scan(source).unwrap();
+}
+
+#[cfg(test)]
+pub fn compare_parsed_to_expected(source: &str, expected: Value) {
+    let tokens = get_tokens(source);
+    let mut parsed = Parser::parse(&tokens).unwrap();
+    let actual = parsed.to_json();
+    assert_json_eq!(actual, expected);
+}
+
+#[macro_export]
+#[cfg(test)]
+macro_rules! generate_parse_test_cases {
+    ($dir:ident, $($file:ident),*) => {
+        $(
+            #[test]
+            fn $file() {
+                let path = format!("src/lang/tests/{}/{}.json", stringify!($dir), stringify!($file));
+                let content_json = fs::read_to_string(&path).unwrap();
+
+                let content: Value = from_str(&content_json).unwrap();
+                let source = content["source"].as_str().unwrap();
+                let expected = content["expected"].clone();
+                compare_parsed_to_expected(source, expected);
+            }
+        )*
+    };
+}
+
+#[macro_export]
+#[cfg(test)]
+macro_rules! parse_tests {
+    ($package:ident / $($file:ident),*) => {
+
+        mod $package {
+            use crate::generate_parse_test_cases;
+            use crate::lang::tests::helpers::compare_parsed_to_expected;
+            use serde_json::{from_str, Value};
+            use std::fs;
+
+            generate_parse_test_cases!($package, $($file),*);
+        }
+    }
+}
diff --git a/server/src/lang/token.rs b/server/src/lang/token.rs
index 627f09e4..4a6b3434 100644
--- a/server/src/lang/token.rs
+++ b/server/src/lang/token.rs
@@ -186,7 +186,7 @@ pub static CASE_SNS_KEYWORDS: phf::Map<&'static str, TokenType> = phf_map! {
     "class" => kw!(Keyword::Class),
     "else" => kw!(Keyword::Else),
     "for" => kw!(Keyword::For),
-    "fun" => kw!(Keyword::Fun),
+    "function" => kw!(Keyword::Fun),
     "if" => kw!(Keyword::If),
     "or" => kw!(Keyword::Or),
     "break" => kw!(Keyword::Break),
diff --git a/server/src/runtime/interpreter.rs b/server/src/runtime/interpreter.rs
index 390714d6..0612c241 100644
--- a/server/src/runtime/interpreter.rs
+++ b/server/src/runtime/interpreter.rs
@@ -55,59 +55,85 @@ pub enum LoopState {
     Go,
     Broken,
     Continue,
+    Function,
 }
 
-#[derive(Debug)]
-pub struct Context {
-    ongoing_loops: Option<Vec<LoopState>>,
+struct LoopStack {
+    ongoing_loops: Vec<LoopState>,
 }
 
-impl Context {
-    pub fn new() -> Context {
-        Context {
-            ongoing_loops: None,
+impl LoopStack {
+    pub fn new() -> LoopStack {
+        LoopStack {
+            ongoing_loops: vec![],
         }
     }
 
-    pub fn push_loop(&mut self, state: LoopState) {
-        if self.ongoing_loops.is_none() {
-            self.ongoing_loops = Some(vec![]);
+    pub fn push_fn(&mut self) {
+        self.ongoing_loops.push(LoopState::Function);
+    }
+
+    pub fn pop_fn(&mut self) {
+        if self.ongoing_loops.last() == Some(&LoopState::Function) {
+            self.ongoing_loops.pop();
         }
-        self.ongoing_loops.as_mut().unwrap().push(state);
+    }
+
+    pub fn push_loop(&mut self, state: LoopState) {
+        self.ongoing_loops.push(state);
     }
 
     pub fn pop_loop(&mut self) {
-        self.ongoing_loops.as_mut().unwrap().pop();
+        if self.is_loops_empty() {
+            return;
+        }
+        self.ongoing_loops.pop();
     }
 
     pub fn is_loops_empty(&self) -> bool {
-        if self.ongoing_loops.is_none() {
-            return true;
-        }
-        return self.ongoing_loops.as_ref().unwrap().is_empty();
+        self.ongoing_loops.is_empty() || self.ongoing_loops.last() == Some(&LoopState::Function)
     }
 
     pub fn get_last_loop(&self) -> Option<&LoopState> {
-        if self.ongoing_loops.is_none() {
+        if self.is_loops_empty() {
             return None;
         }
-        return self.ongoing_loops.as_ref().unwrap().last();
+        return self.ongoing_loops.last();
     }
 
     pub fn set_last_loop(&mut self, to: LoopState) {
-        if self.ongoing_loops.is_none() {
+        if self.ongoing_loops.is_empty() {
             return;
         }
         self.pop_loop();
         self.push_loop(to);
     }
+
+    fn is_loop_at(&self, state: LoopState) -> bool {
+        let last_loop = *self.get_last_loop().unwrap();
+        last_loop == state
+    }
+
+    fn set_loop_state(&mut self, to: LoopState, from: Option<LoopState>) -> bool {
+        if from.is_none() {
+            return if !self.is_loops_empty() {
+                self.set_last_loop(to);
+                true
+            } else {
+                false
+            };
+        } else if self.is_loop_at(from.unwrap()) {
+            self.set_last_loop(to);
+        }
+        true
+    }
 }
 
 pub struct Interpreter {
     env: Shared<Environment>,
     root_env: Shared<Environment>,
     arena: Rc<ParserArena>,
-    call_stack: Vec<Context>,
+    loop_stack: LoopStack,
     resolver: Rc<Resolver>,
 }
 
@@ -121,7 +147,7 @@ impl Interpreter {
             env: env.clone(),
             root_env: env,
             arena: Rc::clone(&arena),
-            call_stack: vec![Context::new()],
+            loop_stack: LoopStack::new(),
             resolver,
         }
     }
@@ -157,27 +183,6 @@ impl Interpreter {
             self.root_env.borrow().read(name)
         }
     }
-}
-
-impl Interpreter {
-    fn is_loop_at(&self, state: LoopState) -> bool {
-        let last_loop = *self.call_stack[0].get_last_loop().unwrap();
-        last_loop == state
-    }
-
-    fn set_loop_state(&mut self, to: LoopState, from: Option<LoopState>) -> bool {
-        if from.is_none() {
-            return if !self.call_stack[0].is_loops_empty() {
-                self.call_stack[0].set_last_loop(to);
-                true
-            } else {
-                false
-            };
-        } else if self.is_loop_at(from.unwrap()) {
-            self.call_stack[0].set_last_loop(to);
-        }
-        true
-    }
 
     pub fn user_fn_call(
         &mut self,
@@ -316,10 +321,11 @@ impl Visitor<RV, HaltReason> for Interpreter {
                     for arg in args.iter() {
                         args_evaluated.push(self.visit_expr(*arg)?);
                     }
-                    self.call_stack.insert(0, Context::new());
+                    self.loop_stack.push_fn();
 
                     let val = callable.call(self, args_evaluated.as_slice());
-                    self.call_stack.remove(0);
+
+                    self.loop_stack.pop_fn();
                     match val {
                         Err(HaltReason::Return(ret_val)) => Ok(ret_val),
                         Ok(unpacked_val) => Ok(unpacked_val),
@@ -410,8 +416,8 @@ impl Visitor<RV, HaltReason> for Interpreter {
     }
 
     fn visit_stmt(&mut self, sidx: StmtId) -> Result<RV, HaltReason> {
-        if !self.call_stack[0].is_loops_empty()
-            && *self.call_stack[0].get_last_loop().unwrap() != LoopState::Go
+        if !self.loop_stack.is_loops_empty()
+            && *self.loop_stack.get_last_loop().unwrap() != LoopState::Go
         {
             return Ok(RV::Undefined);
         }
@@ -452,28 +458,29 @@ impl Visitor<RV, HaltReason> for Interpreter {
                 post,
                 span: _,
             } => {
-                self.call_stack[0].push_loop(LoopState::Go);
-                while !self.is_loop_at(LoopState::Broken)
+                self.loop_stack.push_loop(LoopState::Go);
+                while !self.loop_stack.is_loop_at(LoopState::Broken)
                     && (condition.is_none()
                         || is_value_truthy(self.visit_expr(condition.unwrap())?))
                 {
                     self.visit_stmt(*body)?;
-                    self.set_loop_state(LoopState::Go, Some(LoopState::Continue));
+                    self.loop_stack
+                        .set_loop_state(LoopState::Go, Some(LoopState::Continue));
                     if let Some(post_id) = post {
                         self.visit_stmt(*post_id)?;
                     }
                 }
-                self.call_stack[0].pop_loop();
+                self.loop_stack.pop_loop();
             }
             Stmt::Break { span } => {
-                if !self.set_loop_state(LoopState::Broken, None) {
+                if !self.loop_stack.set_loop_state(LoopState::Broken, None) {
                     return Err(HaltReason::Error(InterpretError::UnexpectedStatement {
                         span: *span,
                     }));
                 }
             }
             Stmt::Continue { span } => {
-                if !self.set_loop_state(LoopState::Continue, None) {
+                if !self.loop_stack.set_loop_state(LoopState::Continue, None) {
                     return Err(HaltReason::Error(InterpretError::UnexpectedStatement {
                         span: *span,
                     }));
diff --git a/server/src/runtime/tests/functions.rs b/server/src/runtime/tests/functions.rs
index ec6a7045..b65d20bf 100644
--- a/server/src/runtime/tests/functions.rs
+++ b/server/src/runtime/tests/functions.rs
@@ -7,11 +7,11 @@ mod test {
     #[test]
     fn test_higher_order_0() {
         exec_assert(
-            "fun f($x, $q) {
+            "function f($x, $q) {
             $x($q);
         };
         
-        fun g($q) {
+        function g($q) {
             TestUtils.out($q);
         };
         
@@ -36,9 +36,9 @@ mod test {
     #[test]
     fn test_high_order_1() {
         exec_assert(
-            "fun makeCounter() {
+            "function makeCounter() {
             var $i = 0;
-            fun count() {
+            function count() {
                 $i = $i + 1;
                 TestUtils.out($i);
             };
@@ -57,7 +57,7 @@ mod test {
         exec_assert(
             "var $a = \"global\";
         {
-          fun showA() {
+          function showA() {
             TestUtils.out($a);
           };
         
@@ -77,14 +77,14 @@ mod test {
         exec_assert(
             "var $a = \"global\";
         {
-            fun showA() {
+            function showA() {
                 TestUtils.out($a);
             };
 
             showA();
             var $a = \"block\";
             showA();
-            fun showB() {
+            function showB() {
                 TestUtils.out($a);
             };
             showB();
@@ -103,7 +103,7 @@ mod test {
             "{
             var $a = \"global\";
             {
-              fun showA() {
+              function showA() {
                 TestUtils.out($a);
               };
           
@@ -124,13 +124,13 @@ mod test {
         exec_assert(
             "var $a = \"global\";
         {
-          fun showA() {
+          function showA() {
             TestUtils.out($a);
           };
         
           var $a = \"block\";
           
-          fun showB() {
+          function showB() {
             TestUtils.out($a);
           };
         
@@ -155,7 +155,7 @@ mod test {
     #[test]
     fn test_anonymous_fn_0() {
         exec_assert(
-            "var $pr = fun a() {
+            "var $pr = function a() {
                     TestUtils.out(\"hello\");
                 };
 
@@ -172,7 +172,7 @@ mod test {
     #[test]
     fn test_anonymous_fn_1() {
         exec_assert(
-            "(fun a() {
+            "(function a() {
                     TestUtils.out(\"hello\");
                   })();
 
@@ -188,7 +188,7 @@ mod test {
     #[test]
     fn test_anonymous_fn_2() {
         exec_assert(
-            "var $pr = fun() {
+            "var $pr = function() {
                     TestUtils.out(\"hello\");
                 };
 
@@ -201,7 +201,7 @@ mod test {
     #[test]
     fn test_anonymous_fn_3() {
         exec_assert(
-            "(fun() {
+            "(function() {
                     TestUtils.out(\"hello\");
                   })();
           ",
@@ -214,13 +214,13 @@ mod test {
         exec_assert(
             "var $a = \"global\";
         {
-          var $showA = fun() {
+          var $showA = function() {
             TestUtils.out($a);
           };
         
           var $a = \"block\";
           
-          var $showB = fun() {
+          var $showB = function() {
             TestUtils.out($a);
           };