Add a default binary so cargo doesnt ask me everyt time what to run

Cargo.toml

@@ -2,7 +2,7 @@
 name = "mclangc"
 version = "0.1.0"
 edition = "2021"
-
+default-run = "mclangc"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]

src/bin/test/main.rs

@@ -1,5 +1,4 @@
 use std::{collections::HashMap, ffi::OsStr, io::Write, os::unix::ffi::OsStrExt, path::{Path, PathBuf}, process::ExitCode};
-use anyhow::bail;
 use camino::Utf8PathBuf;
 use clap::Parser;
 use mclangc;

src/cli.rs

@@ -1,3 +1,39 @@
+use clap::{error::ErrorKind, CommandFactory};
+
+use crate::logger::Level;
 
 
+#[derive(Debug, clap::Parser)]
+pub struct CliArgs {
+    /// Output more info, will get overwritten if -q|--quiet is specified 
+    #[arg(long, short)]
+    verbose: bool,
+    /// Output nothing, except errors, will overwrite -v|--verbose
+    #[arg(long, short)]
+    quiet: bool,
+    /// Output file
+    #[arg(long, short, default_value="a.out")]
+    pub output: String,
+    /// All input files
+    #[clap(num_args = 1..)]
+    pub input: Vec<String>
+}
 
+impl CliArgs {
+    pub fn set_log_level(&self) {
+        if self.quiet {
+            unsafe {
+                crate::logger::LEVEL = Level::Error;
+            }
+        } else if self.verbose {
+            unsafe {
+                crate::logger::LEVEL = Level::Debug;
+            }
+        }
+    }
+    pub fn validate(&self) {
+        if self.input.len() < 1 {
+            CliArgs::command().error(ErrorKind::TooFewValues, "at least one value is required for '<INPUT>' but none was supplied").exit();
+        }
+    }
+}

src/logger.rs

@@ -1,8 +1,8 @@
-use crate::common::Loc;
+pub static mut LEVEL: Level = Level::Info;
-
 
+#[allow(dead_code)]
 #[repr(u8)]
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Level {
     Off = 0,
     Error,
@@ -20,25 +20,37 @@ const C_INFO:  &'static str = "\x1B[1;32m";
 const C_DEBUG: &'static str = "\x1B[1;35m";
 const C_HELP:  &'static str = "\x1B[1;36m";
 
-pub fn _log(level: Level, str: &str) {
+pub fn _log(dbg_loc: Option<(&'static str, u32, u32)>, level: Level, str: &str) {
+    if level > unsafe { LEVEL }{
+        return;
+    }
+    let dbg = if let Some((file, line, col)) = dbg_loc {
+        format!("{file}:{line}:{col}: ")
+    } else {String::new()};
     match level {
        Level::Off => return,
-        Level::Error => println!("{C_ERROR}error{C_RESET}: {str}"),
+       Level::Error => println!("{dbg}{C_ERROR}error{C_RESET}: {str}"),
-        Level::Warn  => println!("{C_WARN}warn{C_RESET}: {str}"),
+       Level::Warn  => println!("{dbg}{C_WARN}warn{C_RESET}: {str}"),
-        Level::Info  => println!("{C_INFO}info{C_RESET}: {str}"),
+       Level::Info  => println!("{dbg}{C_INFO}info{C_RESET}: {str}"),
-        Level::Help  => println!("{C_HELP}help{C_RESET}: {str}"),
+       Level::Help  => println!("{dbg}{C_HELP}help{C_RESET}: {str}"),
-        Level::Debug => println!("{C_DEBUG}debug{C_RESET}: {str}"),
+       Level::Debug => println!("{dbg}{C_DEBUG}debug{C_RESET}: {str}"),
     }
 }
 
-pub fn _log_with_loc(loc: &Loc, level: Level, str: &str) {
+pub fn _log_with_loc(dbg_loc: Option<(&'static str, u32, u32)>, loc: String, level: Level, str: &str) {
+    if level > unsafe { LEVEL }{
+        return;
+    }
+    let dbg = if let Some((file, line, col)) = dbg_loc {
+        format!("{file}:{line}:{col}: ")
+    } else {String::new()};
     match level {
         Level::Off => return,
-        Level::Error => println!("{loc}: {C_ERROR}error{C_RESET}: {str}"),
+        Level::Error => println!("{dbg}{loc}: {C_ERROR}error{C_RESET}: {str}"),
-        Level::Warn  => println!("{loc}: {C_WARN}warn{C_RESET}: {str}"),
+        Level::Warn  => println!("{dbg}{loc}: {C_WARN}warn{C_RESET}: {str}"),
-        Level::Info  => println!("{loc}: {C_INFO}info{C_RESET}: {str}"),
+        Level::Info  => println!("{dbg}{loc}: {C_INFO}info{C_RESET}: {str}"),
-        Level::Help  => println!("{loc}: {C_HELP}help{C_RESET}: {str}"),
+        Level::Help  => println!("{dbg}{loc}: {C_HELP}help{C_RESET}: {str}"),
-        Level::Debug => println!("{loc}: {C_DEBUG}debug{C_RESET}: {str}"),
+        Level::Debug => println!("{dbg}{loc}: {C_DEBUG}debug{C_RESET}: {str}"),
     }
 }
 
@@ -47,31 +59,51 @@ pub mod log {
     #[macro_export]
     macro_rules! error {
         ($($arg:tt)*) => {
-            crate::logger::_log(crate::logger::Level::Error, &format!($($arg)*))
+            if cfg!(debug_assertions) {
+                crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Error, &format!($($arg)*))
+            } else {
+                crate::logger::_log(None, crate::logger::Level::Error, &format!($($arg)*))
+            }
         };
     }
     #[macro_export]
     macro_rules! warn {
         ($($arg:tt)*) => {
-            crate::logger::_log(crate::logger::Level::Warn, &format!($($arg)*))
+            if cfg!(debug_assertions) {
+                crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Warn, &format!($($arg)*))
+            } else {
+                crate::logger::_log(None, crate::logger::Level::Warn, &format!($($arg)*))
+            }
         };
     }
     #[macro_export]
     macro_rules! info {
         ($($arg:tt)*) => {
-            crate::logger::_log(crate::logger::Level::Info, &format!($($arg)*))
+            if cfg!(debug_assertions) {
+                crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Info, &format!($($arg)*))
+            } else {
+                crate::logger::_log(None, crate::logger::Level::Info, &format!($($arg)*))
+            }
         };
     }
     #[macro_export]
     macro_rules! help {
         ($($arg:tt)*) => {
-            crate::logger::_log(crate::logger::Level::Help, &format!($($arg)*))
+            if cfg!(debug_assertions) {
+                crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Help, &format!($($arg)*))
+            } else {
+                crate::logger::_log(None, crate::logger::Level::Help, &format!($($arg)*))
+            }
         };
     }
     #[macro_export]
     macro_rules! debug {
         ($($arg:tt)*) => {
-            crate::logger::_log(crate::logger::Level::Debug, &format!($($arg)*))
+            if cfg!(debug_assertions) {
+                crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Debug, &format!($($arg)*))
+            } else {
+                crate::logger::_log(None, crate::logger::Level::Debug, &format!($($arg)*))
+            }
         };
     }
 
@@ -79,31 +111,51 @@ pub mod log {
     #[macro_export]
     macro_rules! lerror {
         ($loc:expr, $($arg:tt)*) => {
-            crate::logger::_log_with_loc($loc, crate::logger::Level::Error, &format!($($arg)*))
+            if cfg!(debug_assertions) {
+                crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Error, &format!($($arg)*))
+            } else {
+                crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Error, &format!($($arg)*))
+            }
         };
     }
     #[macro_export]
     macro_rules! lwarn {
         ($loc:expr, $($arg:tt)*) => {
-            crate::logger::_log_with_loc($loc, crate::logger::Level::Warn, &format!($($arg)*))
+            if cfg!(debug_assertions) {
+                crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Warn, &format!($($arg)*))
+            } else {
+                crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Warn, &format!($($arg)*))
+            }
         };
     }
     #[macro_export]
     macro_rules! linfo {
         ($loc:expr, $($arg:tt)*) => {
-            crate::logger::_log_with_loc($loc, crate::logger::Level::Info, &format!($($arg)*))
+            if cfg!(debug_assertions) {
+                crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Info, &format!($($arg)*))
+            } else {
+                crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Info, &format!($($arg)*))
+            }
         };
     }
     #[macro_export]
     macro_rules! lhelp {
         ($loc:expr, $($arg:tt)*) => {
-            crate::logger::_log_with_loc($loc, crate::logger::Level::Help, &format!($($arg)*))
+            if cfg!(debug_assertions) {
+                crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Help, &format!($($arg)*))
+            } else {
+                crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Help, &format!($($arg)*))
+            }
         };
     }
     #[macro_export]
     macro_rules! ldebug {
         ($loc:expr, $($arg:tt)*) => {
-            crate::logger::_log_with_loc($loc, crate::logger::Level::Debug, &format!($($arg)*))
+            if cfg!(debug_assertions) {
+                crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Debug, &format!($($arg)*))
+            } else {
+                crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Debug, &format!($($arg)*))
+            }
         };
     }
 }

src/main.rs

@@ -1,11 +1,39 @@
+use std::{path::PathBuf, process::ExitCode};
+
+use clap::Parser;
+// Importing logger here too cause the logger macros dont work outside the mclanc lib
+mod logger;
 
 
 
-fn main() -> anyhow::Result<()> {
-    let data = std::fs::read_to_string("test.mcl").unwrap();
 
-    let tokens = mclangc::tokeniser::tokenise(&data, "test.mcl")?;
+fn main() -> ExitCode {
-    let prog = mclangc::parser::parse_program(tokens)?;
+    let cli = mclangc::cli::CliArgs::parse();
-    mclangc::validator::validate_code(&prog);
+    cli.set_log_level();
-    Ok(())
+    cli.validate();
+    for file in &cli.input {
+        let fp = PathBuf::from(file);
+        if !fp.exists() {
+            error!("File {fp:?} doesnt exits, exiting");
+            return ExitCode::FAILURE;
+        }
+
+        let data = std::fs::read_to_string(fp).unwrap();
+        info!("Tokenising {file}");
+        let Ok(tokens) = mclangc::tokeniser::tokenise(&data, &file) else {
+            error!("Failed to tokenise file, exiting");
+            return ExitCode::FAILURE;
+        };
+        info!("Parsing {file}");
+        let Ok(prog) = mclangc::parser::parse_program(tokens) else {
+            error!("Failed to parse file, exiting");
+            return ExitCode::FAILURE;
+        };
+        info!("Validating {file}");
+        let Ok(validated) = mclangc::validator::validate_code(&prog) else {
+            error!("Failed to validate file, exiting");
+            return ExitCode::FAILURE;
+        };
+    }
+    ExitCode::SUCCESS
 }

src/parser/expr.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use anyhow::{bail, Result};
 
-use crate::{debug, lerror, parser::{typ::parse_type, Punctuation}, tokeniser::Token};
+use crate::{debug, error, lerror, parser::{typ::parse_type, Punctuation}, tokeniser::Token};
 
 use super::{ast::{expr::{Block, CallParams, Expr, IfBranchExpr, IfExpr, Path}, literal::Literal, TokenType}, parse_item, utils, Delimiter, Keyword};
 
@@ -108,13 +108,12 @@ pub fn parse_expr(tokens: &mut Vec<Token>, precedence: usize, consume_semi: bool
         if let Some(_) = utils::check_from_many(tokens, BINOP_LIST) {
             return Ok(Some(parse_binop(tokens, res, precedence)?));
         } else {
-            return Ok(Some(res));
-        }
-        
-    }
             if consume_semi {
                 _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "Expected ; at the end of the expression")?;
             }
+            return Ok(Some(res));
+        } 
+    }
     Ok(res)
 }
 
@@ -138,7 +137,17 @@ fn parse_if(tokens: &mut Vec<Token>) -> Result<IfExpr> {
         lerror!(loc.loc(), "Expected test for if statement, got nothing");
         bail!("")
     };
-    let block = parse_block(tokens)?;
+    let block = if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::CurlyL)) {
+        if let Some(_) = utils::check_2_last(tokens, TokenType::Delim(Delimiter::CurlyR)) {
+            _ = utils::check_consume(tokens, TokenType::Delim(Delimiter::CurlyR));
+            Block(Vec::new())
+        } else {
+            parse_block(tokens)?
+        }
+    } else {
+        lerror!(loc.loc(), "Expected '{{'");
+        bail!("")
+    };
     if let Some(_) = utils::check_consume(tokens, TokenType::Keyword(Keyword::Else)) {
         if let Some(_) = utils::check(tokens, TokenType::Keyword(Keyword::If)) {
             let branch = IfBranchExpr::ElseIf(Box::new(parse_if(tokens)?));
@@ -181,7 +190,7 @@ fn parse_for_loop(tokens: &mut Vec<Token>) -> Result<Expr> {
         lerror!(loc.loc(), "Expected init stat for a for loop, got nothing");
         bail!("")
     };
-    _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "");
+    // Semicolon parsed out by parse_item above
     let Some(test) = parse_expr(tokens, 0, false)? else {
         lerror!(loc.loc(), "Expected test comparrison for a for loop, got nothing");
         bail!("")
@@ -440,14 +449,14 @@ pub fn parse_block(tokens: &mut Vec<Token>) -> Result<Block> {
     utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::CurlyL), "")?;
     let mut items = Vec::new();
     while !tokens.is_empty() {
+        if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::CurlyR)) {
+            break;
+        }
         if let Some(item) = parse_item(tokens)? {
             items.push(item);
         } else {
             break;
         }
-        if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::CurlyR)) {
-            break;
-        }
     }
     utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::CurlyR), "")?;
     Ok(Block(items))

src/parser/typ.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 
-use crate::tokeniser::Token;
+use crate::{parser::Delimiter, tokeniser::Token};
 
 use super::{ast::{typ::Type, TokenType}, expr::parse_expr, utils, Keyword, Punctuation};
 
@@ -15,7 +15,7 @@ pub fn parse_type(tokens: &mut Vec<Token>) -> Result<Type> {
     }
     
     let mut typ;
-    if let Some(_) = utils::check(tokens, TokenType::Delim(super::Delimiter::SquareL)) {
+    if let Some(_) = utils::check_consume(tokens, TokenType::Delim(super::Delimiter::SquareL)) {
         let itm_typ = parse_type(tokens)?;
         if let Some(_) = utils::check_consume(tokens, TokenType::Punct(Punctuation::Semi)) {
            let count = parse_expr(tokens, 0, false)?.unwrap();
@@ -28,6 +28,7 @@ pub fn parse_type(tokens: &mut Vec<Token>) -> Result<Type> {
                inner: Box::new(itm_typ), 
            }
         }
+        _ = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareR), "")?;
     } else {
         let ident = utils::check_consume_or_err(tokens, TokenType::ident(""), "a")?;
         typ = Type::Owned(ident.tt().unwrap_ident());

tests/parser/enumerations.exp

@@ -1,6 +1,33 @@
 Program {
     ast: Block(
-        [],
+        [
+            Statement(
+                Enum {
+                    name: Ident(
+                        "Foo",
+                    ),
+                    fields: [],
+                },
+            ),
+            Statement(
+                Enum {
+                    name: Ident(
+                        "Bar",
+                    ),
+                    fields: [
+                        Ident(
+                            "A",
+                        ),
+                        Ident(
+                            "B",
+                        ),
+                        Ident(
+                            "C",
+                        ),
+                    ],
+                },
+            ),
+        ],
     ),
     structs: {},
     enums: {},

tests/parser/enumerations.mcl

@@ -0,0 +1,7 @@
+enum Foo {}
+
+enum Bar {
+    A,
+    B,
+    C,
+}

tests/parser/expressions.exp

@@ -1,6 +1,57 @@
 Program {
     ast: Block(
-        [],
+        [
+            Expr(
+                BinOp {
+                    typ: Eq,
+                    left: UnOp {
+                        typ: Star,
+                        right: Path(
+                            Path(
+                                [
+                                    Ident(
+                                        "a",
+                                    ),
+                                ],
+                            ),
+                        ),
+                    },
+                    right: BinOp {
+                        typ: EqEq,
+                        left: BinOp {
+                            typ: Star,
+                            left: Literal(
+                                Number(
+                                    Number {
+                                        val: 1,
+                                        base: 10,
+                                        signed: false,
+                                    },
+                                ),
+                            ),
+                            right: Literal(
+                                Number(
+                                    Number {
+                                        val: 3,
+                                        base: 10,
+                                        signed: false,
+                                    },
+                                ),
+                            ),
+                        },
+                        right: Literal(
+                            Number(
+                                Number {
+                                    val: 4,
+                                    base: 10,
+                                    signed: false,
+                                },
+                            ),
+                        ),
+                    },
+                },
+            ),
+        ],
     ),
     structs: {},
     enums: {},

tests/parser/expressions.mcl

@@ -0,0 +1,8 @@
+*a = 1 * 3 == 4;
+b.c = 3/4 == *a;
+c->d = (a->b.c->d) / 2;
+*d->e.f = 2 / a->b.c->d;
+e = a->b.c->d / 2;
+f = a.b.c.d / 2;
+g = a.b[*a.c] * 5;
+

tests/parser/functions.exp

@@ -1,6 +1,191 @@
 Program {
     ast: Block(
-        [],
+        [
+            Statement(
+                Fn {
+                    struct_name: None,
+                    name: Ident(
+                        "main",
+                    ),
+                    params: [
+                        (
+                            Ident(
+                                "argc",
+                            ),
+                            Owned(
+                                Ident(
+                                    "i32",
+                                ),
+                            ),
+                        ),
+                        (
+                            Ident(
+                                "argv",
+                            ),
+                            Ref {
+                                inner: Array {
+                                    inner: Owned(
+                                        Ident(
+                                            "Str",
+                                        ),
+                                    ),
+                                },
+                                mutable: false,
+                            },
+                        ),
+                    ],
+                    ret_type: Some(
+                        Owned(
+                            Ident(
+                                "i32",
+                            ),
+                        ),
+                    ),
+                    qual_const: false,
+                    qual_extern: None,
+                    body: Some(
+                        Block(
+                            [
+                                Expr(
+                                    Return(
+                                        Some(
+                                            Literal(
+                                                Number(
+                                                    Number {
+                                                        val: 0,
+                                                        base: 10,
+                                                        signed: false,
+                                                    },
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ],
+                        ),
+                    ),
+                },
+            ),
+            Statement(
+                Fn {
+                    struct_name: Some(
+                        Ident(
+                            "Baz",
+                        ),
+                    ),
+                    name: Ident(
+                        "main",
+                    ),
+                    params: [
+                        (
+                            Ident(
+                                "self",
+                            ),
+                            Ref {
+                                inner: Owned(
+                                    Ident(
+                                        "Baz",
+                                    ),
+                                ),
+                                mutable: true,
+                            },
+                        ),
+                        (
+                            Ident(
+                                "a",
+                            ),
+                            Ref {
+                                inner: Owned(
+                                    Ident(
+                                        "Foo",
+                                    ),
+                                ),
+                                mutable: false,
+                            },
+                        ),
+                        (
+                            Ident(
+                                "b",
+                            ),
+                            Ref {
+                                inner: Owned(
+                                    Ident(
+                                        "Bar",
+                                    ),
+                                ),
+                                mutable: true,
+                            },
+                        ),
+                    ],
+                    ret_type: Some(
+                        Ref {
+                            inner: Owned(
+                                Ident(
+                                    "Nya",
+                                ),
+                            ),
+                            mutable: false,
+                        },
+                    ),
+                    qual_const: false,
+                    qual_extern: None,
+                    body: None,
+                },
+            ),
+            Statement(
+                Fn {
+                    struct_name: Some(
+                        Ident(
+                            "Baz",
+                        ),
+                    ),
+                    name: Ident(
+                        "main",
+                    ),
+                    params: [
+                        (
+                            Ident(
+                                "a",
+                            ),
+                            Ref {
+                                inner: Owned(
+                                    Ident(
+                                        "Foo",
+                                    ),
+                                ),
+                                mutable: false,
+                            },
+                        ),
+                        (
+                            Ident(
+                                "b",
+                            ),
+                            Ref {
+                                inner: Owned(
+                                    Ident(
+                                        "Bar",
+                                    ),
+                                ),
+                                mutable: true,
+                            },
+                        ),
+                    ],
+                    ret_type: Some(
+                        Ref {
+                            inner: Owned(
+                                Ident(
+                                    "Nya",
+                                ),
+                            ),
+                            mutable: false,
+                        },
+                    ),
+                    qual_const: false,
+                    qual_extern: None,
+                    body: None,
+                },
+            ),
+        ],
     ),
     structs: {},
     enums: {},

tests/parser/functions.mcl

@@ -0,0 +1,5 @@
+fn main(argc: i32, argv: &[Str]) -> i32 {
+    return 0;
+}
+fn Baz.main(self: &mut Baz, a: &Foo, b: &mut Bar) -> &Nya;
+fn Baz.main(a: &Foo, b: &mut Bar) -> &Nya;

tests/parser/if-statements.exp

@@ -1,7 +1,39 @@
 Program {
     ast: Block(
+        [
+            Expr(
+                If(
+                    IfExpr {
+                        test: BinOp {
+                            typ: Gt,
+                            left: Path(
+                                Path(
+                                    [
+                                        Ident(
+                                            "i",
+                                        ),
+                                    ],
+                                ),
+                            ),
+                            right: Literal(
+                                Number(
+                                    Number {
+                                        val: 3,
+                                        base: 10,
+                                        signed: false,
+                                    },
+                                ),
+                            ),
+                        },
+                        body: Block(
                             [],
                         ),
+                        else_if: None,
+                    },
+                ),
+            ),
+        ],
+    ),
     structs: {},
     enums: {},
     types: {},

tests/parser/if-statements.mcl

@@ -0,0 +1,18 @@
+
+if i > 3 {
+
+}
+
+if 1 {
+
+} else {
+
+}
+
+if 1 {
+
+} else if a > 3 {
+
+} else {
+
+}

tests/parser/loops.exp

@@ -1,7 +1,111 @@
 Program {
     ast: Block(
+        [
+            Expr(
+                ForLoop {
+                    init: Statement(
+                        Let {
+                            name: Ident(
+                                "i",
+                            ),
+                            typ: None,
+                            val: Some(
+                                Literal(
+                                    Number(
+                                        Number {
+                                            val: 0,
+                                            base: 10,
+                                            signed: false,
+                                        },
+                                    ),
+                                ),
+                            ),
+                        },
+                    ),
+                    test: BinOp {
+                        typ: Lt,
+                        left: Path(
+                            Path(
+                                [
+                                    Ident(
+                                        "i",
+                                    ),
+                                ],
+                            ),
+                        ),
+                        right: Literal(
+                            Number(
+                                Number {
+                                    val: 10,
+                                    base: 10,
+                                    signed: false,
+                                },
+                            ),
+                        ),
+                    },
+                    on_loop: BinOp {
+                        typ: AddEq,
+                        left: Path(
+                            Path(
+                                [
+                                    Ident(
+                                        "i",
+                                    ),
+                                ],
+                            ),
+                        ),
+                        right: Literal(
+                            Number(
+                                Number {
+                                    val: 1,
+                                    base: 10,
+                                    signed: false,
+                                },
+                            ),
+                        ),
+                    },
+                    body: Block(
                         [],
                     ),
+                },
+            ),
+            Expr(
+                WhileLoop {
+                    test: BinOp {
+                        typ: Gt,
+                        left: Path(
+                            Path(
+                                [
+                                    Ident(
+                                        "i",
+                                    ),
+                                ],
+                            ),
+                        ),
+                        right: Literal(
+                            Number(
+                                Number {
+                                    val: 3,
+                                    base: 10,
+                                    signed: false,
+                                },
+                            ),
+                        ),
+                    },
+                    body: Block(
+                        [],
+                    ),
+                },
+            ),
+            Expr(
+                InfLoop {
+                    body: Block(
+                        [],
+                    ),
+                },
+            ),
+        ],
+    ),
     structs: {},
     enums: {},
     types: {},

tests/parser/loops.mcl

@@ -0,0 +1,3 @@
+for let i = 0; i < 10; i += 1 {}
+while i > 3 {}
+loop {}

tests/parser/structs.exp

@@ -1,6 +1,37 @@
 Program {
     ast: Block(
-        [],
+        [
+            Statement(
+                Struct {
+                    name: Ident(
+                        "foo_t",
+                    ),
+                    fields: [],
+                },
+            ),
+            Statement(
+                Struct {
+                    name: Ident(
+                        "bar_t",
+                    ),
+                    fields: [
+                        (
+                            Ident(
+                                "a",
+                            ),
+                            Ref {
+                                inner: Owned(
+                                    Ident(
+                                        "bar_t",
+                                    ),
+                                ),
+                                mutable: false,
+                            },
+                        ),
+                    ],
+                },
+            ),
+        ],
     ),
     structs: {},
     enums: {},

tests/parser/structs.mcl

@@ -0,0 +1,6 @@
+
+struct foo_t {}
+
+struct bar_t {
+    a: &bar_t
+}