From bc98b29723777266c43a1bca55bc82ffc50129e9 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Tue, 22 Oct 2024 21:31:17 +0200
Subject: [PATCH 01/43] =?UTF-8?q?=F0=9F=8E=89=20Start=20of=20rewrite?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 .gitignore               |   1 +
 src/diagnostic.rs        | 167 ----------------
 src/files.rs             |  84 --------
 src/main.rs              |  65 +------
 src/parser/ast.rs        |  53 ------
 src/parser/expression.rs | 142 --------------
 src/parser/lookup.rs     | 227 ----------------------
 src/parser/macros.rs     | 145 --------------
 src/parser/mod.rs        | 219 ---------------------
 src/parser/statement.rs  | 155 ---------------
 src/parser/typing.rs     | 128 -------------
 src/scanner/lexeme.rs    | 229 ----------------------
 src/scanner/mod.rs       | 402 ---------------------------------------
 src/transpiler/bend.rs   | 135 -------------
 src/transpiler/mod.rs    |   7 -
 15 files changed, 3 insertions(+), 2156 deletions(-)
 delete mode 100644 src/diagnostic.rs
 delete mode 100644 src/files.rs
 delete mode 100644 src/parser/ast.rs
 delete mode 100644 src/parser/expression.rs
 delete mode 100644 src/parser/lookup.rs
 delete mode 100644 src/parser/macros.rs
 delete mode 100644 src/parser/mod.rs
 delete mode 100644 src/parser/statement.rs
 delete mode 100644 src/parser/typing.rs
 delete mode 100644 src/scanner/lexeme.rs
 delete mode 100644 src/scanner/mod.rs
 delete mode 100644 src/transpiler/bend.rs
 delete mode 100644 src/transpiler/mod.rs

diff --git a/.gitignore b/.gitignore
index ea8c4bf..5733f74 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 /target
+/.history
diff --git a/src/diagnostic.rs b/src/diagnostic.rs
deleted file mode 100644
index 739d85f..0000000
--- a/src/diagnostic.rs
+++ /dev/null
@@ -1,167 +0,0 @@
-use crate::scanner::lexeme::Lexeme;
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Diagnostic<'a> {
-    pub severity: Severity,
-    pub title: String,
-    pub errors: Vec<Error<'a>>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Error<'a> {
-    pub message: String,
-    pub label: Label,
-    pub range: Range<'a>,
-}
-
-impl<'a> Error<'a> {
-    pub fn primary(
-        file_id: impl Into<&'a str>,
-        position: usize,
-        length: usize,
-        message: impl Into<String>,
-    ) -> Error<'a> {
-        Error::new(file_id, Label::Primary, position, length, message)
-    }
-
-    pub fn secondary(
-        file_id: impl Into<&'a str>,
-        position: usize,
-        length: usize,
-        message: impl Into<String>,
-    ) -> Error<'a> {
-        Error::new(file_id, Label::Secondary, position, length, message)
-    }
-
-    pub fn new(
-        file_id: impl Into<&'a str>,
-        label: Label,
-        position: usize,
-        length: usize,
-        message: impl Into<String>,
-    ) -> Error<'a> {
-        Error {
-            message: message.into(),
-            label,
-            range: Range {
-                file_id: file_id.into(),
-                position,
-                length,
-            },
-        }
-    }
-
-    pub(crate) fn transform_range(mut self, lexemes: &'a [Lexeme<'a>]) -> Error {
-        self.range = self.range.to_source_code_range(lexemes);
-        self
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Severity {
-    Error,
-    Warning,
-    Note,
-    Help,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Label {
-    Primary,
-    Secondary,
-}
-
-impl From<Severity> for codespan_reporting::diagnostic::Severity {
-    fn from(val: Severity) -> Self {
-        match val {
-            Severity::Error => codespan_reporting::diagnostic::Severity::Error,
-            Severity::Warning => codespan_reporting::diagnostic::Severity::Warning,
-            Severity::Note => codespan_reporting::diagnostic::Severity::Note,
-            Severity::Help => codespan_reporting::diagnostic::Severity::Help,
-        }
-    }
-}
-
-impl<'a> Diagnostic<'a> {
-    pub fn error(message: impl Into<String>) -> Diagnostic<'a> {
-        Diagnostic::new(Severity::Error, message)
-    }
-
-    pub fn warning(message: impl Into<String>) -> Diagnostic<'a> {
-        Diagnostic::new(Severity::Warning, message)
-    }
-
-    pub fn new(severity: Severity, message: impl Into<String>) -> Diagnostic<'a> {
-        Diagnostic {
-            severity,
-            title: message.into(),
-            errors: vec![],
-        }
-    }
-
-    pub fn with_error(mut self, error: Error<'a>) -> Self {
-        self.errors.push(error);
-        self
-    }
-}
-
-impl<'a> From<Diagnostic<'a>> for codespan_reporting::diagnostic::Diagnostic<&'a str> {
-    fn from(val: Diagnostic<'a>) -> Self {
-        codespan_reporting::diagnostic::Diagnostic::<&'a str>::new(val.severity.into())
-            .with_message(val.title)
-            .with_labels(val.errors.into_iter().map(|error| error.into()).collect())
-    }
-}
-
-impl<'a> From<Error<'a>> for codespan_reporting::diagnostic::Label<&'a str> {
-    fn from(val: Error<'a>) -> Self {
-        codespan_reporting::diagnostic::Label::new(
-            val.label.into(),
-            val.range.file_id,
-            val.range.position..val.range.position + val.range.length,
-        )
-        .with_message(val.message)
-    }
-}
-
-impl From<Label> for codespan_reporting::diagnostic::LabelStyle {
-    fn from(val: Label) -> Self {
-        match val {
-            Label::Primary => codespan_reporting::diagnostic::LabelStyle::Primary,
-            Label::Secondary => codespan_reporting::diagnostic::LabelStyle::Secondary,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Hash, PartialEq, Eq)]
-pub struct Range<'a> {
-    pub file_id: &'a str,
-    pub position: usize,
-    pub length: usize,
-}
-
-impl<'a> Range<'a> {
-    pub fn to_source_code_range(self, lexemes: &[Lexeme]) -> Self {
-        let start = if self.position >= lexemes.len() {
-            let last_lexeme = lexemes[lexemes.len() - 1].range();
-            last_lexeme.position + 1
-        } else {
-            let start_lexeme = lexemes[self.position].range();
-            start_lexeme.position
-        };
-
-        let end = if self.position + self.length >= lexemes.len() {
-            let last_lexeme = lexemes[lexemes.len() - 1].range();
-            last_lexeme.position + last_lexeme.length
-        } else {
-            let end_lexeme = lexemes[self.position + self.length].range();
-            end_lexeme.position + end_lexeme.length
-        };
-
-        Range {
-            file_id: self.file_id,
-            position: start,
-            length: end - start,
-        }
-    }
-}
diff --git a/src/files.rs b/src/files.rs
deleted file mode 100644
index 625d5eb..0000000
--- a/src/files.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use std::collections::HashMap;
-
-#[derive(Default)]
-pub struct Files<'a> {
-    pub files: HashMap<&'a str, &'a str>,
-}
-
-impl<'a> Files<'a> {
-    pub fn insert(&mut self, file_id: impl Into<&'a str>, source: impl Into<&'a str>) {
-        self.files.insert(file_id.into(), source.into());
-    }
-
-    pub fn file_ids(&self) -> Vec<&'a str> {
-        self.files.keys().copied().collect()
-    }
-
-    pub fn get(&self, file_id: impl Into<&'a str>) -> Option<&'a str> {
-        self.files.get(file_id.into()).copied()
-    }
-}
-
-impl<'a> codespan_reporting::files::Files<'a> for Files<'a> {
-    type FileId = &'a str;
-    type Name = &'a str;
-    type Source = &'a str;
-
-    fn name(&'a self, id: Self::FileId) -> Result<Self::Name, codespan_reporting::files::Error> {
-        self.files
-            .keys()
-            .find(|key| **key == id)
-            .copied()
-            .ok_or(codespan_reporting::files::Error::FileMissing)
-    }
-
-    fn source(
-        &'a self,
-        id: Self::FileId,
-    ) -> Result<Self::Source, codespan_reporting::files::Error> {
-        self.files
-            .get(id)
-            .ok_or(codespan_reporting::files::Error::FileMissing)
-            .copied()
-    }
-
-    fn line_index(
-        &'a self,
-        id: Self::FileId,
-        byte_index: usize,
-    ) -> Result<usize, codespan_reporting::files::Error> {
-        self.get(id)
-            .ok_or(codespan_reporting::files::Error::FileMissing)
-            .map(|source| {
-                source
-                    .char_indices()
-                    .take_while(|(index, _)| *index < byte_index)
-                    .filter(|(_, character)| *character == '\n')
-                    .count()
-            })
-    }
-
-    fn line_range(
-        &'a self,
-        id: Self::FileId,
-        line_index: usize,
-    ) -> Result<std::ops::Range<usize>, codespan_reporting::files::Error> {
-        self.get(id)
-            .ok_or(codespan_reporting::files::Error::FileMissing)
-            .map(|source| {
-                let start = source
-                    .lines()
-                    .take(line_index)
-                    .map(|line| line.len() + 1)
-                    .sum::<usize>();
-
-                let end = source
-                    .lines()
-                    .take(line_index + 1)
-                    .map(|line| line.len() + 1)
-                    .sum::<usize>();
-
-                start..end
-            })
-    }
-}
diff --git a/src/main.rs b/src/main.rs
index 23700a3..e7a11a9 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,64 +1,3 @@
-use anyhow::Result;
-use codespan_reporting::{
-    diagnostic::Diagnostic,
-    term::{
-        self,
-        termcolor::{ColorChoice, StandardStream},
-    },
-};
-use core::result::Result::Ok;
-use files::Files;
-use transpiler::{bend::BendTranspiler, Transpiler};
-
-pub mod diagnostic;
-pub mod files;
-pub mod parser;
-pub mod scanner;
-pub mod transpiler;
-
-fn main() -> Result<()> {
-    let mut files = Files::default();
-    files.insert(
-        "main",
-        "
-        enum hello:
-            a
-            b
-            c;
-    ",
-    );
-
-    let scanner = scanner::Scanner::new(&files);
-    let lexemes = scanner.parse();
-
-    println!("{:#?}", lexemes);
-
-    let mut parser = parser::Parser::new(&lexemes);
-    let parsed = parser.parse();
-
-    match &parsed {
-        Ok(_) => {}
-        Err(diagnostics) => {
-            // Print the diagnostics
-            for diagnostic in diagnostics.iter() {
-                println!("{:?}", diagnostic);
-            }
-
-            let diagnostics: Vec<Diagnostic<&str>> =
-                diagnostics.iter().map(|d| d.clone().into()).collect();
-
-            let writer = StandardStream::stderr(ColorChoice::Auto);
-            let config = codespan_reporting::term::Config::default();
-
-            for diagnostic in diagnostics {
-                term::emit(&mut writer.lock(), &config, &files, &diagnostic)?;
-            }
-        }
-    }
-
-    let transpiled = BendTranspiler::transpile(&parsed.unwrap());
-
-    println!("{}", transpiled);
-
-    Ok(())
+fn main() {
+    println!("Hello, world!");
 }
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
deleted file mode 100644
index 1fb94c3..0000000
--- a/src/parser/ast.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use std::collections::{HashMap, HashSet};
-
-use crate::scanner::lexeme::Lexeme;
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum Symbol<'a> {
-    Expression(Expression),
-    Statement(Statement),
-    Type(Type),
-    Unknown(Lexeme<'a>),
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum Expression {
-    Number(f64),
-    String(String),
-    Identifier(String),
-    Unary(UnaryOperation, Box<Expression>),
-    Binary(Box<Expression>, BinaryOperation, Box<Expression>),
-    Grouping(Box<Expression>),
-    Assignment(Box<Expression>, Box<Expression>),
-    StructInitializer(String, HashMap<String, Expression>),
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum Statement {
-    Block(Vec<Statement>),
-    Declaration(String, Option<Type>, Expression),
-    Expression(Expression),
-    Struct(String, HashMap<String, Type>),
-    Enum(String, HashSet<String>),
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum UnaryOperation {
-    Negate,
-    Inverse,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum BinaryOperation {
-    Plus,
-    Minus,
-    Times,
-    Divide,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Type {
-    Symbol(String),
-    Array(Box<Type>),
-    Tuple(HashMap<String, Type>),
-}
diff --git a/src/parser/expression.rs b/src/parser/expression.rs
deleted file mode 100644
index 714853f..0000000
--- a/src/parser/expression.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use super::{
-    ast::{Expression, UnaryOperation},
-    lookup::BindingPower,
-    macros::{expect_expression, expect_token_value, expect_tokens, expect_valid_token},
-    Parser,
-};
-use crate::{
-    diagnostic::Error,
-    parser::macros::expect_any_token,
-    scanner::lexeme::{Lexeme, TokenType, TokenValue},
-};
-use std::collections::HashMap;
-
-pub fn parse<'a>(
-    parser: &'a Parser<'a>,
-    cursor: usize,
-    binding_power: &BindingPower,
-) -> Result<(Expression, usize), Error<'a>> {
-    let mut cursor = cursor;
-    let (token, range) = expect_valid_token!(parser, cursor)?;
-    let expression_handler = parser
-        .lookup
-        .expression_lookup
-        .get(&token.token_type)
-        .ok_or(Error::primary(
-            range.file_id,
-            cursor,
-            range.length,
-            "Expected a new expression",
-        ))?;
-
-    let (mut left_hand_side, new_cursor) = expression_handler(parser, cursor)?;
-
-    cursor = new_cursor;
-
-    while let Some(Lexeme::Valid(token)) = parser.lexemes.get(cursor) {
-        let token_binding_power = parser
-            .lookup
-            .binding_power_lookup
-            .get(&token.token_type)
-            .unwrap_or(&BindingPower::None);
-
-        if binding_power > token_binding_power {
-            break;
-        }
-
-        let left_expression_handler =
-            match parser.lookup.left_expression_lookup.get(&token.token_type) {
-                Some(handler) => handler,
-                None => break,
-            };
-
-        let (right_hand_side, new_cursor) =
-            left_expression_handler(parser, cursor, left_hand_side, token_binding_power)?;
-
-        cursor = new_cursor;
-        left_hand_side = right_hand_side;
-    }
-
-    Ok((left_hand_side, cursor))
-}
-
-pub fn parse_assignment<'a>(
-    parser: &'a Parser<'a>,
-    cursor: usize,
-    lhs: Expression,
-    binding_power: &BindingPower,
-) -> Result<(Expression, usize), Error<'a>> {
-    let (_, cursor) = expect_tokens!(parser, cursor, TokenType::Equal)?;
-    let (rhs, cursor) = expect_expression!(parser, cursor, binding_power)?;
-
-    Ok((Expression::Assignment(Box::new(lhs), Box::new(rhs)), cursor))
-}
-
-pub fn parse_unary<'a>(
-    parser: &'a Parser<'a>,
-    cursor: usize,
-) -> Result<(Expression, usize), Error<'a>> {
-    let (token, cursor) = expect_any_token!(parser, cursor, TokenType::Minus, TokenType::Not)?;
-    match token.token_type {
-        TokenType::Minus => {
-            let (expression, cursor) = expect_expression!(parser, cursor, &BindingPower::Unary)?;
-            Ok((
-                Expression::Unary(UnaryOperation::Negate, Box::new(expression)),
-                cursor,
-            ))
-        }
-        TokenType::Not => {
-            let (expression, cursor) = expect_expression!(parser, cursor, &BindingPower::Unary)?;
-            Ok((
-                Expression::Unary(UnaryOperation::Inverse, Box::new(expression)),
-                cursor,
-            ))
-        }
-        _ => unreachable!(),
-    }
-}
-
-pub fn parse_struct_initializer<'a>(
-    parser: &'a Parser<'a>,
-    cursor: usize,
-    lhs: Expression,
-    binding_power: &BindingPower,
-) -> Result<(Expression, usize), Error<'a>> {
-    let identifier = match lhs {
-        Expression::Identifier(identifier) => identifier.clone(),
-        _ => {
-            unreachable!()
-        }
-    };
-
-    let (_, cursor) = expect_tokens!(parser, cursor, TokenType::CurlyOpen)?;
-
-    let mut members = HashMap::new();
-    let mut new_cursor = cursor;
-
-    while let Some(Lexeme::Valid(token)) = parser.lexemes.get(new_cursor) {
-        if token.token_type == TokenType::CurlyClose {
-            break;
-        }
-
-        if !members.is_empty() {
-            let (_, cursor) = expect_tokens!(parser, new_cursor, TokenType::Comma)?;
-            new_cursor = cursor;
-        }
-
-        let (tokens, cursor) =
-            expect_tokens!(parser, new_cursor, TokenType::Identifier, TokenType::Colon)?;
-
-        let identifier = expect_token_value!(tokens[0], TokenValue::Identifier);
-
-        let (expression, cursor) = expect_expression!(parser, cursor, binding_power)?;
-
-        members.insert(identifier, expression);
-
-        new_cursor = cursor;
-    }
-
-    let (_, cursor) = expect_tokens!(parser, new_cursor, TokenType::CurlyClose)?;
-
-    Ok((Expression::StructInitializer(identifier, members), cursor))
-}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
deleted file mode 100644
index 73fa1f6..0000000
--- a/src/parser/lookup.rs
+++ /dev/null
@@ -1,227 +0,0 @@
-use super::{
-    ast::{BinaryOperation, Expression, Statement, Type},
-    expression,
-    macros::{expect_expression, expect_tokens},
-    statement, typing, Parser,
-};
-use crate::{
-    diagnostic::Error,
-    parser::macros::expect_token_value,
-    scanner::lexeme::{TokenType, TokenValue},
-};
-use core::panic;
-use std::collections::HashMap;
-
-#[derive(Debug, PartialEq, PartialOrd)]
-pub enum BindingPower {
-    None = 0,
-    Comma = 1,
-    Assignment = 2,
-    Logical = 3,
-    Relational = 4,
-    Additive = 5,
-    Multiplicative = 6,
-    Unary = 7,
-    Call = 8,
-    Member = 9,
-    Primary = 10,
-}
-
-pub type TypeHandler<'a> = fn(&'a Parser<'a>, usize) -> Result<(Type, usize), Error<'a>>;
-pub type LeftTypeHandler<'a> =
-    fn(&'a Parser<'a>, usize, Type, &BindingPower) -> Result<(Type, usize), Error<'a>>;
-pub type StatementHandler<'a> = fn(&'a Parser<'a>, usize) -> Result<(Statement, usize), Error<'a>>;
-pub type ExpressionHandler<'a> =
-    fn(&'a Parser<'a>, usize) -> Result<(Expression, usize), Error<'a>>;
-pub type LeftExpressionHandler<'a> =
-    fn(&'a Parser<'a>, usize, Expression, &BindingPower) -> Result<(Expression, usize), Error<'a>>;
-
-pub struct Lookup<'a> {
-    pub statement_lookup: HashMap<TokenType, StatementHandler<'a>>,
-    pub expression_lookup: HashMap<TokenType, ExpressionHandler<'a>>,
-    pub left_expression_lookup: HashMap<TokenType, LeftExpressionHandler<'a>>,
-    pub type_lookup: HashMap<TokenType, TypeHandler<'a>>,
-    pub left_type_lookup: HashMap<TokenType, LeftTypeHandler<'a>>,
-    pub binding_power_lookup: HashMap<TokenType, BindingPower>,
-}
-
-impl<'a> Lookup<'a> {
-    pub(crate) fn add_statement_handler(
-        &mut self,
-        token: TokenType,
-        handler: StatementHandler<'a>,
-    ) {
-        if self.statement_lookup.contains_key(&token) {
-            panic!("Token already has a statement handler");
-        }
-
-        self.statement_lookup.insert(token, handler);
-    }
-
-    pub(crate) fn add_expression_handler(
-        &mut self,
-        token: TokenType,
-        handler: ExpressionHandler<'a>,
-    ) {
-        if self.expression_lookup.contains_key(&token) {
-            panic!("Token already has an expression handler");
-        }
-
-        self.expression_lookup.insert(token, handler);
-    }
-
-    pub(crate) fn add_left_expression_handler(
-        &mut self,
-        token: TokenType,
-        binding_power: BindingPower,
-        handler: LeftExpressionHandler<'a>,
-    ) {
-        if self.binding_power_lookup.contains_key(&token) {
-            panic!("Token already has a binding power");
-        }
-
-        self.left_expression_lookup.insert(token.clone(), handler);
-        self.binding_power_lookup.insert(token, binding_power);
-    }
-
-    pub(crate) fn add_type_handler(&mut self, token: TokenType, handler: TypeHandler<'a>) {
-        if self.type_lookup.contains_key(&token) {
-            panic!("Token already has a type handler");
-        }
-
-        self.type_lookup.insert(token, handler);
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn add_left_type_handler(&mut self, token: TokenType, handler: LeftTypeHandler<'a>) {
-        if self.left_type_lookup.contains_key(&token) {
-            panic!("Token already has a left type handler");
-        }
-
-        self.left_type_lookup.insert(token, handler);
-    }
-}
-
-impl<'a> Default for Lookup<'a> {
-    fn default() -> Self {
-        let mut lookup = Lookup {
-            statement_lookup: HashMap::new(),
-            expression_lookup: HashMap::new(),
-            left_expression_lookup: HashMap::new(),
-            binding_power_lookup: HashMap::new(),
-            type_lookup: HashMap::new(),
-            left_type_lookup: HashMap::new(),
-        };
-
-        // Addative
-        lookup.add_left_expression_handler(
-            TokenType::Plus,
-            BindingPower::Additive,
-            |parser, cursor, lhs, _binding| {
-                let (_, cursor) = expect_tokens!(parser, cursor, TokenType::Plus)?;
-                let (rhs, cursor) = expect_expression!(parser, cursor, &BindingPower::Additive)?;
-                Ok((
-                    Expression::Binary(Box::new(lhs), BinaryOperation::Plus, Box::new(rhs)),
-                    cursor,
-                ))
-            },
-        );
-
-        lookup.add_left_expression_handler(
-            TokenType::Minus,
-            BindingPower::Additive,
-            |parser, cursor, lhs, _binding| {
-                let (_, cursor) = expect_tokens!(parser, cursor, TokenType::Minus)?;
-                let (rhs, cursor) = expect_expression!(parser, cursor, &BindingPower::Additive)?;
-                Ok((
-                    Expression::Binary(Box::new(lhs), BinaryOperation::Minus, Box::new(rhs)),
-                    cursor,
-                ))
-            },
-        );
-
-        // Multiplicative
-        lookup.add_left_expression_handler(
-            TokenType::Star,
-            BindingPower::Multiplicative,
-            |parser, cursor, lhs, _binding| {
-                let (_, cursor) = expect_tokens!(parser, cursor, TokenType::Star)?;
-                let (rhs, cursor) =
-                    expect_expression!(parser, cursor, &BindingPower::Multiplicative)?;
-                Ok((
-                    Expression::Binary(Box::new(lhs), BinaryOperation::Times, Box::new(rhs)),
-                    cursor,
-                ))
-            },
-        );
-
-        lookup.add_left_expression_handler(
-            TokenType::Slash,
-            BindingPower::Multiplicative,
-            |parser, cursor, lhs, _binding| {
-                let (_, cursor) = expect_tokens!(parser, cursor, TokenType::Slash)?;
-                let (rhs, cursor) =
-                    expect_expression!(parser, cursor, &BindingPower::Multiplicative)?;
-                Ok((
-                    Expression::Binary(Box::new(lhs), BinaryOperation::Divide, Box::new(rhs)),
-                    cursor,
-                ))
-            },
-        );
-
-        // Literals and symbols
-        lookup.add_expression_handler(TokenType::Decimal, |parser, cursor| {
-            let (decimal, cursor) = expect_tokens!(parser, cursor, TokenType::Decimal)?;
-            let decimal = expect_token_value!(decimal[0], TokenValue::Decimal);
-            Ok((Expression::Number(decimal), cursor))
-        });
-
-        lookup.add_expression_handler(TokenType::Integer, |parser, cursor| {
-            let (integer, cursor) = expect_tokens!(parser, cursor, TokenType::Integer)?;
-            let integer = expect_token_value!(integer[0], TokenValue::Integer);
-            Ok((Expression::Number(integer as f64), cursor))
-        });
-
-        lookup.add_expression_handler(TokenType::String, |parser, cursor| {
-            let (string, cursor) = expect_tokens!(parser, cursor, TokenType::String)?;
-            let string = expect_token_value!(string[0], TokenValue::String);
-            Ok((Expression::String(string), cursor))
-        });
-
-        lookup.add_expression_handler(TokenType::Identifier, |parser, cursor| {
-            let (identifier, cursor) = expect_tokens!(parser, cursor, TokenType::Identifier)?;
-            let identifier = expect_token_value!(identifier[0], TokenValue::Identifier);
-            Ok((Expression::Identifier(identifier), cursor))
-        });
-
-        lookup.add_expression_handler(TokenType::ParenOpen, |parser, cursor| {
-            let (_, cursor) = expect_tokens!(parser, cursor, TokenType::ParenOpen)?;
-            let (expression, cursor) = expect_expression!(parser, cursor, &BindingPower::None)?;
-            let (_, cursor) = expect_tokens!(parser, cursor, TokenType::ParenClose)?;
-            Ok((Expression::Grouping(Box::new(expression)), cursor))
-        });
-
-        lookup.add_expression_handler(TokenType::Minus, expression::parse_unary);
-        lookup.add_expression_handler(TokenType::Not, expression::parse_unary);
-        lookup.add_statement_handler(TokenType::Let, statement::parse_declaration);
-        lookup.add_left_expression_handler(
-            TokenType::Equal,
-            BindingPower::Assignment,
-            expression::parse_assignment,
-        );
-
-        lookup.add_left_expression_handler(
-            TokenType::CurlyOpen,
-            BindingPower::Primary,
-            expression::parse_struct_initializer,
-        );
-        lookup.add_type_handler(TokenType::Identifier, typing::parse_symbol);
-        lookup.add_type_handler(TokenType::SquareOpen, typing::parse_array);
-        lookup.add_type_handler(TokenType::CurlyOpen, typing::parse_tuple);
-
-        lookup.add_statement_handler(TokenType::Struct, statement::parse_struct);
-        lookup.add_statement_handler(TokenType::Enum, statement::parse_enum);
-
-        lookup
-    }
-}
diff --git a/src/parser/macros.rs b/src/parser/macros.rs
deleted file mode 100644
index 3c9c383..0000000
--- a/src/parser/macros.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-#[allow(unused_macros)]
-macro_rules! expect_statement {
-    ($parser:expr, $cursor:expr) => {{
-        crate::parser::statement::parse($parser, $cursor)
-    }};
-}
-
-macro_rules! expect_expression {
-    ($parser:expr, $cursor:expr, $binding_power:expr) => {{
-        crate::parser::expression::parse($parser, $cursor, &$binding_power)
-    }};
-}
-
-macro_rules! expect_type {
-    ($parser:expr, $cursor:expr, $binding_power:expr) => {{
-        crate::parser::typing::parse($parser, $cursor, &$binding_power)
-    }};
-}
-
-macro_rules! expect_valid_token {
-    ($parser:expr, $cursor:expr) => {{
-        let lexeme = $parser.lexemes.get($cursor);
-
-        match lexeme {
-            Some(lexeme) => match lexeme {
-                Lexeme::Valid(token) => Ok((token, lexeme.range())),
-                Lexeme::Invalid(_) => Err(crate::diagnostic::Error::primary(
-                    lexeme.range().file_id,
-                    $cursor,
-                    1,
-                    "Invalid token",
-                )),
-            },
-            None => Err(crate::diagnostic::Error::primary(
-                $parser.lexemes.get(0).unwrap().range().file_id,
-                $cursor + 1,
-                0,
-                "Unexpected end of file",
-            )),
-        }
-    }};
-}
-
-// allows for multiple token types to be expected
-// peek_any_token!(parser, cursor, TokenType::Plus, TokenType::Minus);
-macro_rules! expect_any_token {
-    ($parser:expr, $cursor:expr, $($token_type:expr),*) => {{
-        let expected_token_types = vec![$($token_type.to_string()),*];
-
-        let lexeme = $parser.lexemes.get($cursor);
-
-        match lexeme {
-            Some(lexeme) => match lexeme {
-                Lexeme::Valid(token) => {
-                    if expected_token_types.contains(&token.token_type.to_string()) {
-                        Ok((token, $cursor + 1))
-                    } else {
-                        Err(crate::diagnostic::Error::primary(
-                            lexeme.range().file_id,
-                            $cursor,
-                            1,
-                            format!("Expected {}", expected_token_types.join(" or ")),
-                        ))
-                    }
-                }
-                Lexeme::Invalid(_) => Err(crate::diagnostic::Error::primary(
-                    lexeme.range().file_id,
-                    $cursor,
-                    1,
-                    "Invalid token",
-                )),
-            },
-            None => Err(crate::diagnostic::Error::primary(
-                $parser.lexemes.get(0).unwrap().range().file_id,
-                $cursor + 1,
-                0,
-                "Unexpected end of file",
-            )),
-        }
-    }};
-}
-
-#[allow(unused_macros)]
-macro_rules! expect_optional_token {
-    ($parser:expr, $cursor:expr, $token_type:expr) => {{
-        let result = expect_tokens!($parser, $cursor, $token_type);
-
-        match result {
-            Ok((token, cursor)) => Ok((Some(token), cursor)),
-            Err(_) => Ok((None, $cursor)),
-        }
-    }};
-}
-macro_rules! expect_token_value {
-    ($token:expr, $value:path) => {{
-        match &$token.value {
-            $value(value) => value.clone(),
-            _ => panic!("expect_token_value! should only return identifiers"),
-        }
-    }};
-}
-
-macro_rules! expect_tokens {
-    ($parser:expr, $cursor:expr, $($token_type:expr),*) => {{
-        let mut i = $cursor;
-        let mut tokens = Vec::new();
-        let mut valid = 0;
-
-        $(
-            let lexeme: Option<&crate::scanner::lexeme::Lexeme> = $parser.lexemes.get(i);
-
-            match lexeme {
-                Some(crate::scanner::lexeme::Lexeme::Valid(token)) => {
-                    if token.token_type == $token_type {
-                        tokens.push(token.clone());
-                        valid += 1;
-                    }
-                }
-                _ => {}
-            };
-
-            i += 1;
-        )*
-
-        let all_tokens = vec![$($token_type),*];
-
-        if valid == all_tokens.len() {
-            Ok((tokens, i))
-        } else {
-            let unexpected_tokens = all_tokens.iter().skip(valid).map(|t| t.to_string()).collect::<Vec<_>>();
-            Err(crate::diagnostic::Error::primary($parser.lexemes.get(0).unwrap().range().file_id, $cursor + valid, 1, format!("Expected {}", unexpected_tokens.join(" and "))))
-        }
-    }};
-}
-
-pub(crate) use expect_any_token;
-pub(crate) use expect_expression;
-#[allow(unused_imports)]
-pub(crate) use expect_optional_token;
-#[allow(unused_imports)]
-pub(crate) use expect_statement;
-pub(crate) use expect_token_value;
-pub(crate) use expect_tokens;
-pub(crate) use expect_type;
-pub(crate) use expect_valid_token;
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
deleted file mode 100644
index 1fcfe30..0000000
--- a/src/parser/mod.rs
+++ /dev/null
@@ -1,219 +0,0 @@
-use crate::{
-    diagnostic::{Diagnostic, Error},
-    scanner::lexeme::Lexeme,
-};
-use ast::{Statement, Symbol};
-use lookup::Lookup;
-use std::collections::HashSet;
-
-pub mod ast;
-pub mod expression;
-pub mod lookup;
-pub mod macros;
-pub mod statement;
-pub mod typing;
-
-pub struct Parser<'a> {
-    lookup: Lookup<'a>,
-    lexemes: &'a Vec<Lexeme<'a>>,
-}
-
-impl<'a> Parser<'a> {
-    pub fn new(lexemes: &'a Vec<Lexeme<'a>>) -> Self {
-        Self {
-            lookup: Lookup::default(),
-            lexemes,
-        }
-    }
-
-    pub fn parse(&'a mut self) -> Result<Symbol, HashSet<Diagnostic>> {
-        let mut statements = vec![];
-        let mut diagnostics = HashSet::new();
-        let mut last_safe_cursor = 0;
-        let mut cursor = 0;
-        let mut panic_mode = false;
-
-        while cursor < self.lexemes.len() {
-            if panic_mode {
-                // Skip to the next valid statement
-                while let Some(lexeme) = self.lexemes.get(cursor) {
-                    // Try to parse the next statement
-                    if lexeme.is_valid() && statement::parse(self, cursor).is_ok() {
-                        diagnostics.insert(
-                            Diagnostic::warning("Unparsed code").with_error(
-                                Error::primary(
-                                    lexeme.range().file_id,
-                                    cursor,
-                                    cursor - last_safe_cursor,
-                                    "This code was not parsed",
-                                )
-                                .transform_range(self.lexemes),
-                            ),
-                        );
-
-                        break;
-                    };
-
-                    cursor += 1;
-                }
-            }
-
-            match statement::parse(self, cursor) {
-                Ok((statement, new_cursor)) => {
-                    cursor = new_cursor;
-                    last_safe_cursor = new_cursor;
-                    statements.push(statement);
-                }
-                Err(error) => {
-                    diagnostics.insert(
-                        Diagnostic::error("Syntax error")
-                            .with_error(error.clone().transform_range(self.lexemes)),
-                    );
-                    panic_mode = true;
-                }
-            };
-        }
-
-        if diagnostics.is_empty() {
-            Ok(Symbol::Statement(Statement::Block(statements)))
-        } else {
-            Err(diagnostics)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use ast::{BinaryOperation, Expression};
-
-    use crate::{files::Files, scanner::Scanner};
-
-    use super::*;
-
-    #[test]
-    fn parses_addition() {
-        test_parser(
-            "123 + 456;",
-            Symbol::Statement(Statement::Block(vec![Statement::Expression(
-                Expression::Binary(
-                    Box::new(Expression::Number(123.0)),
-                    BinaryOperation::Plus,
-                    Box::new(Expression::Number(456.0)),
-                ),
-            )])),
-        );
-    }
-
-    #[test]
-    fn parses_subtraction() {
-        test_parser(
-            "123 - 456;",
-            Symbol::Statement(Statement::Block(vec![Statement::Expression(
-                Expression::Binary(
-                    Box::new(Expression::Number(123.0)),
-                    BinaryOperation::Minus,
-                    Box::new(Expression::Number(456.0)),
-                ),
-            )])),
-        );
-    }
-
-    #[test]
-    fn parses_multiplication() {
-        test_parser(
-            "123 * 456;",
-            Symbol::Statement(Statement::Block(vec![Statement::Expression(
-                Expression::Binary(
-                    Box::new(Expression::Number(123.0)),
-                    BinaryOperation::Times,
-                    Box::new(Expression::Number(456.0)),
-                ),
-            )])),
-        );
-    }
-
-    #[test]
-    fn parses_division() {
-        test_parser(
-            "123 / 456;",
-            Symbol::Statement(Statement::Block(vec![Statement::Expression(
-                Expression::Binary(
-                    Box::new(Expression::Number(123.0)),
-                    BinaryOperation::Divide,
-                    Box::new(Expression::Number(456.0)),
-                ),
-            )])),
-        );
-    }
-
-    #[test]
-    fn parses_long_expression() {
-        test_parser(
-            "123 + 456 - 789 + 101;",
-            Symbol::Statement(Statement::Block(vec![Statement::Expression(
-                Expression::Binary(
-                    Box::new(Expression::Number(123.0)),
-                    BinaryOperation::Plus,
-                    Box::new(Expression::Binary(
-                        Box::new(Expression::Number(456.0)),
-                        BinaryOperation::Minus,
-                        Box::new(Expression::Binary(
-                            Box::new(Expression::Number(789.0)),
-                            BinaryOperation::Plus,
-                            Box::new(Expression::Number(101.0)),
-                        )),
-                    )),
-                ),
-            )])),
-        );
-    }
-
-    #[test]
-    fn gives_precedence_to_multiplication() {
-        test_parser(
-            "123 * 456 + 789;",
-            Symbol::Statement(Statement::Block(vec![Statement::Expression(
-                Expression::Binary(
-                    Box::new(Expression::Binary(
-                        Box::new(Expression::Number(123.0)),
-                        BinaryOperation::Times,
-                        Box::new(Expression::Number(456.0)),
-                    )),
-                    BinaryOperation::Plus,
-                    Box::new(Expression::Number(789.0)),
-                ),
-            )])),
-        );
-    }
-
-    #[test]
-    fn parses_expression_grouping() {
-        test_parser(
-            "(123 + 456) * 789;",
-            Symbol::Statement(Statement::Block(vec![Statement::Expression(
-                Expression::Binary(
-                    Box::new(Expression::Grouping(Box::new(Expression::Binary(
-                        Box::new(Expression::Number(123.0)),
-                        BinaryOperation::Plus,
-                        Box::new(Expression::Number(456.0)),
-                    )))),
-                    BinaryOperation::Times,
-                    Box::new(Expression::Number(789.0)),
-                ),
-            )])),
-        );
-    }
-
-    fn test_parser(code: &str, expected: Symbol) {
-        let mut files = Files::default();
-        files.insert("test", code);
-
-        let scanner = Scanner::new(&files);
-        let lexemes = scanner.parse();
-
-        let mut parser = Parser::new(&lexemes);
-        let parsed = parser.parse().unwrap();
-
-        assert_eq!(parsed, expected);
-    }
-}
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
deleted file mode 100644
index c0c32a1..0000000
--- a/src/parser/statement.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-use super::{
-    ast::Type,
-    expression,
-    lookup::BindingPower,
-    macros::{
-        expect_any_token, expect_expression, expect_token_value, expect_tokens, expect_type,
-        expect_valid_token,
-    },
-    Parser, Statement,
-};
-use crate::{
-    diagnostic::Error,
-    scanner::lexeme::{Lexeme, TokenType, TokenValue},
-};
-use core::panic;
-use std::collections::{HashMap, HashSet};
-
-pub fn parse<'a>(parser: &'a Parser<'a>, cursor: usize) -> Result<(Statement, usize), Error<'a>> {
-    let (token, _) = expect_valid_token!(parser, cursor)?;
-    let statement_handler = parser.lookup.statement_lookup.get(&token.token_type);
-
-    match statement_handler {
-        Some(statement_handler) => statement_handler(parser, cursor),
-        None => parse_expression(parser, cursor),
-    }
-}
-
-pub fn parse_expression<'a>(
-    parser: &'a Parser<'a>,
-    cursor: usize,
-) -> Result<(Statement, usize), Error<'a>> {
-    let (expression, cursor) = expression::parse(parser, cursor, &BindingPower::None)?;
-    let (_, cursor) = expect_tokens!(parser, cursor, TokenType::Semicolon)?;
-
-    Ok((Statement::Expression(expression), cursor))
-}
-
-pub fn parse_declaration<'a>(
-    parser: &'a Parser<'a>,
-    cursor: usize,
-) -> Result<(Statement, usize), Error<'a>> {
-    let (_, cursor) = expect_tokens!(parser, cursor, TokenType::Let)?;
-    let (identifier, cursor) = expect_tokens!(parser, cursor, TokenType::Identifier)?;
-    let identifier = match &identifier[0].value {
-        TokenValue::Identifier(identifier) => identifier,
-        _ => panic!("expect_token! should return a valid token and handle the error case"),
-    };
-
-    let (token, _) = expect_any_token!(parser, cursor, TokenType::Colon, TokenType::Equal)?;
-    let (typing, cursor) = match token.token_type {
-        TokenType::Colon => {
-            let (_, cursor) = expect_tokens!(parser, cursor, TokenType::Colon)?;
-            let (typing, cursor) = expect_type!(parser, cursor, BindingPower::None)?;
-            (Some(typing), cursor)
-        }
-        _ => (None, cursor),
-    };
-
-    let (_, cursor) = expect_tokens!(parser, cursor, TokenType::Equal)?;
-    let (expression, cursor) = expect_expression!(parser, cursor, &BindingPower::None)?;
-    let (_, cursor) = expect_tokens!(parser, cursor, TokenType::Semicolon)?;
-
-    Ok((
-        Statement::Declaration(identifier.clone(), typing, expression),
-        cursor,
-    ))
-}
-
-pub fn parse_struct<'a>(
-    parser: &'a Parser<'a>,
-    cursor: usize,
-) -> Result<(Statement, usize), Error<'a>> {
-    let (tokens, cursor) = expect_tokens!(
-        parser,
-        cursor,
-        TokenType::Struct,
-        TokenType::Identifier,
-        TokenType::Colon
-    )?;
-
-    let identifier = expect_token_value!(tokens[1], TokenValue::Identifier);
-
-    let mut new_cursor = cursor;
-    let mut members: HashMap<String, Type> = HashMap::new();
-
-    while let Some(Lexeme::Valid(token)) = parser.lexemes.get(new_cursor) {
-        let (member_name, member_type, cursor) = match token.token_type {
-            TokenType::Semicolon => break,
-            _ => {
-                let (tokens, cursor) = expect_tokens!(
-                    parser,
-                    new_cursor,
-                    TokenType::Dot,
-                    TokenType::Identifier,
-                    TokenType::Colon
-                )?;
-
-                let identifier = expect_token_value!(tokens[1], TokenValue::Identifier);
-
-                let (field_type, cursor) = expect_type!(parser, cursor, BindingPower::None)?;
-
-                (identifier, field_type, cursor)
-            }
-        };
-
-        // TODO: Handle warning for overwritten member
-        members.insert(member_name, member_type);
-
-        new_cursor = cursor;
-    }
-
-    let (_, cursor) = expect_tokens!(parser, new_cursor, TokenType::Semicolon)?;
-
-    Ok((Statement::Struct(identifier, members), cursor))
-}
-
-pub fn parse_enum<'a>(
-    parser: &'a Parser<'a>,
-    cursor: usize,
-) -> Result<(Statement, usize), Error<'a>> {
-    let (tokens, cursor) = expect_tokens!(
-        parser,
-        cursor,
-        TokenType::Enum,
-        TokenType::Identifier,
-        TokenType::Colon
-    )?;
-
-    let identifier = expect_token_value!(tokens[1], TokenValue::Identifier);
-
-    let mut new_cursor = cursor;
-    let mut members: HashSet<String> = HashSet::new();
-
-    while let Some(Lexeme::Valid(token)) = parser.lexemes.get(new_cursor) {
-        let (member_name, cursor) = match token.token_type {
-            TokenType::Semicolon => break,
-            _ => {
-                let (field_name, cursor) =
-                    expect_tokens!(parser, new_cursor, TokenType::Identifier)?;
-
-                let field_name = expect_token_value!(field_name[0], TokenValue::Identifier);
-
-                (field_name, cursor)
-            }
-        };
-
-        new_cursor = cursor;
-        // TODO: Handle warning for overwritten members
-        members.insert(member_name);
-    }
-
-    let (_, cursor) = expect_tokens!(parser, new_cursor, TokenType::Semicolon)?;
-
-    Ok((Statement::Enum(identifier, members), cursor))
-}
diff --git a/src/parser/typing.rs b/src/parser/typing.rs
deleted file mode 100644
index e1eff57..0000000
--- a/src/parser/typing.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-use std::collections::HashMap;
-
-use super::{
-    ast::Type,
-    lookup::BindingPower,
-    macros::{expect_optional_token, expect_tokens, expect_type, expect_valid_token},
-    Parser,
-};
-use crate::{
-    diagnostic::Error,
-    scanner::lexeme::{Lexeme, TokenType, TokenValue},
-};
-
-pub fn parse<'a>(
-    parser: &'a Parser<'a>,
-    cursor: usize,
-    binding_power: &BindingPower,
-) -> Result<(Type, usize), Error<'a>> {
-    let mut cursor = cursor;
-    let (token, range) = expect_valid_token!(parser, cursor)?;
-    let type_handler = parser
-        .lookup
-        .type_lookup
-        .get(&token.token_type)
-        .ok_or(Error::primary(
-            parser.lexemes.get(cursor).unwrap().range().file_id,
-            cursor,
-            range.length,
-            "Expected a type",
-        ))?;
-
-    let (mut left_hand_side, new_cursor) = type_handler(parser, cursor)?;
-
-    cursor = new_cursor;
-
-    while let Some(Lexeme::Valid(token)) = parser.lexemes.get(cursor) {
-        let token_binding_power = parser
-            .lookup
-            .binding_power_lookup
-            .get(&token.token_type)
-            .unwrap_or(&BindingPower::None);
-
-        if binding_power > token_binding_power {
-            break;
-        }
-
-        let left_type_handler = match parser.lookup.left_type_lookup.get(&token.token_type) {
-            Some(handler) => handler,
-            None => break,
-        };
-
-        let (right_hand_side, new_cursor) =
-            left_type_handler(parser, cursor, left_hand_side, token_binding_power)?;
-
-        cursor = new_cursor;
-        left_hand_side = right_hand_side;
-    }
-
-    Ok((left_hand_side, cursor))
-}
-
-pub fn parse_symbol<'a>(parser: &'a Parser, cursor: usize) -> Result<(Type, usize), Error<'a>> {
-    let (identifier, cursor) = expect_tokens!(parser, cursor, TokenType::Identifier)?;
-    let identifier = match &identifier[0].value {
-        TokenValue::Identifier(identifier) => identifier,
-        _ => panic!("expect_token! should only return identifiers"),
-    };
-    Ok((Type::Symbol(identifier.clone()), cursor))
-}
-
-pub fn parse_array<'a>(parser: &'a Parser<'a>, cursor: usize) -> Result<(Type, usize), Error<'a>> {
-    let (_, cursor) = expect_tokens!(parser, cursor, TokenType::SquareOpen)?;
-    let (element_type, cursor) = expect_type!(parser, cursor, &BindingPower::None)?;
-    let (_, cursor) = expect_tokens!(parser, cursor, TokenType::SquareClose)?;
-    Ok((Type::Array(Box::new(element_type)), cursor))
-}
-
-pub fn parse_tuple<'a>(parser: &'a Parser<'a>, cursor: usize) -> Result<(Type, usize), Error<'a>> {
-    let (_, cursor) = expect_tokens!(parser, cursor, TokenType::CurlyOpen)?;
-    let mut new_cursor = cursor;
-    let mut members: HashMap<String, Type> = HashMap::new();
-
-    while let Some(Lexeme::Valid(token)) = parser.lexemes.get(new_cursor) {
-        let (member_name, member_type, cursor) = match token.token_type {
-            TokenType::CurlyClose => break,
-            _ => {
-                if !members.is_empty() {
-                    let (_, cursor) = expect_tokens!(parser, new_cursor, TokenType::Comma)?;
-                    new_cursor = cursor;
-                }
-
-                let (colon, _) = expect_optional_token!(parser, new_cursor + 1, TokenType::Colon)?;
-
-                match colon {
-                    Some(_) => {
-                        let (field_name, cursor) =
-                            expect_tokens!(parser, new_cursor, TokenType::Identifier)?;
-                        let field_name = match &field_name[0].value {
-                            TokenValue::Identifier(field_name) => field_name.clone(),
-                            _ => panic!("expect_token! should only return identifiers"),
-                        };
-
-                        let (_, cursor) = expect_tokens!(parser, cursor, TokenType::Colon)?;
-                        let (field_type, cursor) =
-                            expect_type!(parser, cursor, BindingPower::None)?;
-
-                        (field_name, field_type, cursor)
-                    }
-                    None => {
-                        let field_name = members.len().to_string();
-                        let (field_type, cursor) =
-                            expect_type!(parser, new_cursor, BindingPower::None)?;
-                        (field_name, field_type, cursor)
-                    }
-                }
-            }
-        };
-
-        // TODO: Check for duplicate member names
-        members.insert(member_name, member_type);
-
-        new_cursor = cursor;
-    }
-
-    let (_, cursor) = expect_tokens!(parser, new_cursor, TokenType::CurlyClose)?;
-
-    Ok((Type::Tuple(members), cursor))
-}
diff --git a/src/scanner/lexeme.rs b/src/scanner/lexeme.rs
deleted file mode 100644
index e8001e4..0000000
--- a/src/scanner/lexeme.rs
+++ /dev/null
@@ -1,229 +0,0 @@
-use std::{fmt::Display, hash::Hash};
-
-use crate::diagnostic::Range;
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum Lexeme<'a> {
-    Valid(Token<'a>),
-    Invalid(Range<'a>),
-}
-
-impl<'a> Display for Lexeme<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Lexeme::Valid(token) => write!(f, "`{}`", token.token_type),
-            Lexeme::Invalid(range) => write!(f, "`Invalid token at {:?}`", range),
-        }
-    }
-}
-
-impl<'a> Lexeme<'a> {
-    pub fn valid(
-        file_id: impl Into<&'a str>,
-        token_type: TokenType,
-        value: TokenValue,
-        start: usize,
-        length: usize,
-    ) -> Lexeme<'a> {
-        Lexeme::Valid(Token::new(
-            token_type,
-            value,
-            Range {
-                file_id: file_id.into(),
-                position: start,
-                length,
-            },
-        ))
-    }
-
-    pub fn invalid(file_id: impl Into<&'a str>, start: usize, length: usize) -> Lexeme<'a> {
-        Lexeme::Invalid(Range {
-            file_id: file_id.into(),
-            position: start,
-            length,
-        })
-    }
-
-    pub fn range(&self) -> &Range {
-        match self {
-            Lexeme::Valid(token) => &token.range,
-            Lexeme::Invalid(range) => range,
-        }
-    }
-
-    pub fn is_valid(&self) -> bool {
-        matches!(self, Lexeme::Valid(_))
-    }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Token<'a> {
-    pub token_type: TokenType,
-    pub value: TokenValue,
-    /// The range of the token in the source code.
-    pub range: Range<'a>,
-}
-
-impl<'a> Token<'a> {
-    pub fn new(token_type: TokenType, value: TokenValue, range: Range) -> Token {
-        Token {
-            token_type,
-            value,
-            range,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum TokenValue {
-    None,
-    Boolean(bool),
-    Integer(i64),
-    Decimal(f64),
-    String(String),
-    Character(char),
-    Identifier(String),
-}
-
-#[derive(Debug, PartialEq, Eq, Hash, Clone)]
-pub enum TokenType {
-    /// A token that should be ignored. This is used for whitespace, comments, etc.
-    Ignore,
-
-    /// The opening of an indentation level.
-    IndentationOpen,
-    /// The closing of an indentation level.
-    IndentationClose,
-
-    /// An opening parenthesis; `(`.
-    ParenOpen,
-    /// A closing parenthesis; `)`.
-    ParenClose,
-    /// An opening curly brace; `{`.
-    CurlyOpen,
-    /// A closing curly brace; `}`.
-    CurlyClose,
-    /// An opening square bracket; `[`.
-    SquareOpen,
-    /// A closing square bracket; `]`.
-    SquareClose,
-
-    /// A comma; `,`.
-    Comma,
-    /// A dot; `.`.
-    Dot,
-    /// A colon; `:`.
-    Colon,
-    /// A semicolon; `;`.
-    Semicolon,
-
-    /// A plus sign; `+`;
-    Plus,
-    /// A minus sign; `-`.
-    Minus,
-    /// A forward slash; `/`.
-    Slash,
-    /// An asterisk; `*`.
-    Star,
-
-    /// An equals sign; `=`.
-    Equal,
-    /// A negetion sign; `!`.
-    Not,
-    /// A less-than sign; `<`.
-    LessThan,
-    /// A greater-than sign; `>`.
-    GreaterThan,
-    /// A less-than-or-equal sign; `<=`.
-    LessThanOrEqual,
-    /// A greater-than-or-equal sign; `>=`.
-    GreaterThanOrEqual,
-    /// An equality sign; `==`.
-    Equality,
-    /// An inequality sign; `!=`.
-    Inequality,
-
-    /// An if keyword; `if`.
-    If,
-    /// An else keyword; `else`.
-    Else,
-
-    /// A while keyword; `while`.
-    While,
-    /// A for keyword; `for`.
-    For,
-
-    /// A var keyword; `var`.
-    Let,
-
-    /// A function keyword; `fn`.
-    Function,
-    /// A return keyword; `return`.
-    Return,
-
-    /// A boolean; `true`, `false`.
-    Boolean,
-    /// A number; `42`, `12`, `-7`.
-    Integer,
-    /// A decimal; `3.14`, `2.718`, `-1.0`.
-    Decimal,
-    /// A string; `"foo"`, `"bar"`, `"baz"`.
-    String,
-    /// A character; `'a'`, `'b'`, `'c'`.
-    Character,
-
-    /// An identifying name; `foo`, `bar`, `baz`.
-    Identifier,
-
-    /// A struct keyword; `struct`.
-    Struct,
-    /// A enum keyword; `enum`.
-    Enum,
-}
-
-impl Display for TokenType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            TokenType::Ignore => write!(f, ""),
-            TokenType::IndentationOpen => write!(f, "opening indentation level"),
-            TokenType::IndentationClose => write!(f, "closing indentation level"),
-            TokenType::ParenOpen => write!(f, "`(`"),
-            TokenType::ParenClose => write!(f, "`)`"),
-            TokenType::CurlyOpen => write!(f, "`{{`"),
-            TokenType::CurlyClose => write!(f, "`}}`"),
-            TokenType::SquareOpen => write!(f, "`[`"),
-            TokenType::SquareClose => write!(f, "`]`"),
-            TokenType::Comma => write!(f, "`,`"),
-            TokenType::Dot => write!(f, "`.`"),
-            TokenType::Colon => write!(f, "`:`"),
-            TokenType::Semicolon => write!(f, "`;`"),
-            TokenType::Plus => write!(f, "`+`"),
-            TokenType::Minus => write!(f, "`-`"),
-            TokenType::Slash => write!(f, "`/`"),
-            TokenType::Star => write!(f, "`*`"),
-            TokenType::Equal => write!(f, "`=`"),
-            TokenType::Not => write!(f, "`!`"),
-            TokenType::LessThan => write!(f, "`<`"),
-            TokenType::GreaterThan => write!(f, "`>`"),
-            TokenType::LessThanOrEqual => write!(f, "`<=`"),
-            TokenType::GreaterThanOrEqual => write!(f, "`>=`"),
-            TokenType::Equality => write!(f, "`==`"),
-            TokenType::Inequality => write!(f, "`!=`"),
-            TokenType::If => write!(f, "`if`"),
-            TokenType::Else => write!(f, "`else`"),
-            TokenType::While => write!(f, "`while`"),
-            TokenType::For => write!(f, "`for`"),
-            TokenType::Let => write!(f, "`let`"),
-            TokenType::Function => write!(f, "`fn`"),
-            TokenType::Return => write!(f, "`return`"),
-            TokenType::Boolean => write!(f, "a boolean value"),
-            TokenType::Integer => write!(f, "an integer value"),
-            TokenType::Decimal => write!(f, "a decimal value"),
-            TokenType::String => write!(f, "a string value"),
-            TokenType::Character => write!(f, "a character value"),
-            TokenType::Identifier => write!(f, "an identifier"),
-            TokenType::Struct => write!(f, "`struct`"),
-            TokenType::Enum => write!(f, "`enum`"),
-        }
-    }
-}
diff --git a/src/scanner/mod.rs b/src/scanner/mod.rs
deleted file mode 100644
index 579aa37..0000000
--- a/src/scanner/mod.rs
+++ /dev/null
@@ -1,402 +0,0 @@
-use std::cmp::Ordering;
-
-use crate::files::Files;
-use lexeme::Lexeme;
-use lexeme::TokenType;
-use lexeme::TokenValue;
-use regex::Regex;
-
-pub mod lexeme;
-
-type SpecItem = (Regex, fn(&str) -> (TokenType, TokenValue));
-
-macro_rules! r {
-    ($pattern:expr) => {
-        Regex::new(format!("^{}", $pattern).as_str()).unwrap()
-    };
-}
-
-pub struct Scanner<'a> {
-    files: &'a Files<'a>,
-    spec: Vec<SpecItem>,
-}
-
-impl<'a> Scanner<'a> {
-    pub fn new(files: &'a Files) -> Scanner<'a> {
-        Scanner {
-            files,
-            spec: vec![
-                (r!(r"(\s+)"), |_| (TokenType::Ignore, TokenValue::None)),
-                (r!(r"//(.*)"), |_| (TokenType::Ignore, TokenValue::None)),
-                (r!(r"(\()"), |_| (TokenType::ParenOpen, TokenValue::None)),
-                (r!(r"(\))"), |_| (TokenType::ParenClose, TokenValue::None)),
-                (r!(r"(\{)"), |_| (TokenType::CurlyOpen, TokenValue::None)),
-                (r!(r"(\})"), |_| (TokenType::CurlyClose, TokenValue::None)),
-                (r!(r"(\[)"), |_| (TokenType::SquareOpen, TokenValue::None)),
-                (r!(r"(\])"), |_| (TokenType::SquareClose, TokenValue::None)),
-                (r!(r"(\,)"), |_| (TokenType::Comma, TokenValue::None)),
-                (r!(r"(\.)"), |_| (TokenType::Dot, TokenValue::None)),
-                (r!(r"(\:)"), |_| (TokenType::Colon, TokenValue::None)),
-                (r!(r"(;)"), |_| (TokenType::Semicolon, TokenValue::None)),
-                (r!(r"(\+)"), |_| (TokenType::Plus, TokenValue::None)),
-                (r!(r"(-)"), |_| (TokenType::Minus, TokenValue::None)),
-                (r!(r"(/)"), |_| (TokenType::Slash, TokenValue::None)),
-                (r!(r"(\*)"), |_| (TokenType::Star, TokenValue::None)),
-                (r!(r"(=)"), |_| (TokenType::Equal, TokenValue::None)),
-                (r!(r"(!)"), |_| (TokenType::Not, TokenValue::None)),
-                (r!(r"(<)"), |_| (TokenType::LessThan, TokenValue::None)),
-                (r!(r"(>)"), |_| (TokenType::GreaterThan, TokenValue::None)),
-                (r!(r"(<=)"), |_| {
-                    (TokenType::LessThanOrEqual, TokenValue::None)
-                }),
-                (r!(r"(>=)"), |_| {
-                    (TokenType::GreaterThanOrEqual, TokenValue::None)
-                }),
-                (r!(r"(==)"), |_| (TokenType::Equality, TokenValue::None)),
-                (r!(r"(!=)"), |_| (TokenType::Inequality, TokenValue::None)),
-                (r!(r"(if)"), |_| (TokenType::If, TokenValue::None)),
-                (r!(r"(else)"), |_| (TokenType::Else, TokenValue::None)),
-                (r!(r"(while)"), |_| (TokenType::While, TokenValue::None)),
-                (r!(r"(for)"), |_| (TokenType::For, TokenValue::None)),
-                (r!(r"(let)"), |_| (TokenType::Let, TokenValue::None)),
-                (r!(r"(fn)"), |_| (TokenType::Function, TokenValue::None)),
-                (r!(r"(return)"), |_| (TokenType::Return, TokenValue::None)),
-                (r!(r"(struct)"), |_| (TokenType::Struct, TokenValue::None)),
-                (r!(r"(enum)"), |_| (TokenType::Enum, TokenValue::None)),
-                (r!(r"(true)"), |_| {
-                    (TokenType::Boolean, TokenValue::Boolean(true))
-                }),
-                (r!(r"(false)"), |_| {
-                    (TokenType::Boolean, TokenValue::Boolean(false))
-                }),
-                (r!(r"(\d+\.\d+)"), |value| {
-                    (
-                        TokenType::Decimal,
-                        TokenValue::Decimal(value.parse().unwrap()),
-                    )
-                }),
-                (r!(r"(\d+)"), |value| {
-                    (
-                        TokenType::Integer,
-                        TokenValue::Integer(value.parse().unwrap()),
-                    )
-                }),
-                (r!(r"'([^']*)'"), |value| {
-                    (TokenType::String, TokenValue::String(value.to_string()))
-                }),
-                (r!(r"`([^`]*)`"), |value| {
-                    (
-                        TokenType::Character,
-                        TokenValue::Character(value.chars().next().unwrap()),
-                    )
-                }),
-                (r!(r"([a-zA-Z_]\w*)"), |value| {
-                    (
-                        TokenType::Identifier,
-                        TokenValue::Identifier(value.to_string()),
-                    )
-                }),
-            ],
-        }
-    }
-
-    pub fn parse(&self) -> Vec<Lexeme> {
-        let mut lexemes = Vec::new();
-
-        for file in self.files.file_ids() {
-            let content = self.files.get(file).unwrap();
-            let mut cursor = 0;
-
-            let mut panic_start_at = None;
-            let indentation_level = 0;
-
-            while cursor < content.chars().count() {
-                let haystack = content.chars().skip(cursor).collect::<String>();
-                let mut was_matched = false;
-
-                for (regex, handler) in &self.spec {
-                    let capture = regex.captures(&haystack);
-
-                    if let Some((capture, matched)) =
-                        capture.and_then(|c| Some((c.get(0)?, c.get(1)?)))
-                    {
-                        if let Some(start) = panic_start_at.take() {
-                            lexemes.push(Lexeme::invalid(file, start, cursor - start - 1));
-                        }
-
-                        let value = matched.as_str();
-                        let (token_type, token_value) = handler(value);
-
-                        if token_type == TokenType::Ignore {
-                            was_matched = true;
-
-                            // Walk all the characters in the token. If the character is an \n, set indentation level to 0.
-                            //  If its a \t increase indentation level by one
-
-                            let mut indentation = 0;
-
-                            for c in capture.as_str().chars() {
-                                if c == '\n' {
-                                    indentation = 0;
-                                }
-
-                                if c == '\t' {
-                                    indentation += 1;
-                                }
-                            }
-
-                            match indentation.cmp(&indentation_level) {
-                                Ordering::Greater => {
-                                    lexemes.push(Lexeme::valid(
-                                        file,
-                                        TokenType::IndentationOpen,
-                                        TokenValue::None,
-                                        cursor,
-                                        1,
-                                    ));
-                                }
-                                Ordering::Less => {
-                                    lexemes.push(Lexeme::valid(
-                                        file,
-                                        TokenType::IndentationClose,
-                                        TokenValue::None,
-                                        cursor,
-                                        1,
-                                    ));
-                                }
-                                _ => {}
-                            }
-
-                            cursor += capture.as_str().chars().count();
-                            break;
-                        }
-
-                        let length = capture.as_str().chars().count();
-                        let lexeme = Lexeme::valid(file, token_type, token_value, cursor, length);
-
-                        lexemes.push(lexeme);
-
-                        cursor += length;
-                        was_matched = true;
-                        break;
-                    }
-                }
-
-                if !was_matched && panic_start_at.is_none() {
-                    panic_start_at = Some(cursor);
-                }
-
-                if !was_matched {
-                    cursor += 1;
-                }
-            }
-        }
-
-        lexemes
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parses_indentation() {
-        test_scanner(
-            "struct enum:\n",
-            vec![
-                (TokenType::Integer, TokenValue::Integer(1), 0, 1),
-                (TokenType::IndentationOpen, TokenValue::None, 1, 1),
-                (TokenType::Integer, TokenValue::Integer(2), 3, 1),
-            ],
-        );
-    }
-
-    #[test]
-    fn ignores_whitespace() {
-        test_scanner("  \t\n", vec![]);
-    }
-
-    #[test]
-    fn ignores_comments() {
-        test_scanner("// this is a comment", vec![]);
-    }
-
-    #[test]
-    fn parses_integers() {
-        test_scanner(
-            "123",
-            vec![(TokenType::Integer, TokenValue::Integer(123), 0, 3)],
-        );
-    }
-
-    #[test]
-    fn parses_decimals() {
-        test_scanner(
-            "123.456",
-            vec![(TokenType::Decimal, TokenValue::Decimal(123.456), 0, 7)],
-        );
-    }
-
-    #[test]
-    fn parses_strings() {
-        test_scanner(
-            "'hello'",
-            vec![(
-                TokenType::String,
-                TokenValue::String("hello".to_string()),
-                0,
-                7,
-            )],
-        );
-    }
-
-    #[test]
-    fn parses_characters() {
-        test_scanner(
-            "`a`",
-            vec![(TokenType::Character, TokenValue::Character('a'), 0, 3)],
-        );
-    }
-    #[test]
-    fn parses_emoji() {
-        test_scanner(
-            "`🦀`",
-            vec![(TokenType::Character, TokenValue::Character('🦀'), 0, 3)],
-        );
-    }
-
-    #[test]
-    fn parses_identifiers() {
-        test_scanner(
-            "foo",
-            vec![(
-                TokenType::Identifier,
-                TokenValue::Identifier("foo".to_string()),
-                0,
-                3,
-            )],
-        );
-    }
-
-    #[test]
-    fn parses_operators() {
-        test_scanner(
-            "+ - / * =",
-            vec![
-                (TokenType::Plus, TokenValue::None, 0, 1),
-                (TokenType::Minus, TokenValue::None, 2, 1),
-                (TokenType::Slash, TokenValue::None, 4, 1),
-                (TokenType::Star, TokenValue::None, 6, 1),
-                (TokenType::Equal, TokenValue::None, 8, 1),
-            ],
-        );
-    }
-    #[test]
-    fn parses_parentheses() {
-        test_scanner(
-            "( )",
-            vec![
-                (TokenType::ParenOpen, TokenValue::None, 0, 1),
-                (TokenType::ParenClose, TokenValue::None, 2, 1),
-            ],
-        );
-    }
-
-    #[test]
-    fn parses_curly_braces() {
-        test_scanner(
-            "{ }",
-            vec![
-                (TokenType::CurlyOpen, TokenValue::None, 0, 1),
-                (TokenType::CurlyClose, TokenValue::None, 2, 1),
-            ],
-        );
-    }
-
-    #[test]
-    fn parses_multiple_tokens() {
-        test_scanner(
-            "123 + 456",
-            vec![
-                (TokenType::Integer, TokenValue::Integer(123), 0, 3),
-                (TokenType::Plus, TokenValue::None, 4, 1),
-                (TokenType::Integer, TokenValue::Integer(456), 6, 3),
-            ],
-        );
-    }
-
-    // #[test]
-    // fn parses_invalid_lexeme() {
-    //     test_scanner(
-    //         "123~456",
-    //         vec![
-    //             (TokenType::Integer, TokenValue::Integer(123), 0, 3),
-    //             Lexeme::invalid(3, 1),
-    //             (TokenType::Integer, TokenValue::Integer(456), 4, 3),
-    //         ],
-    //     );
-    // }
-
-    // #[test]
-    // fn parses_invalid_lexeme_at_end() {
-    //     test_scanner(
-    //         "123~~~±±±",
-    //         vec![
-    //             (TokenType::Integer, TokenValue::Integer(123), 0, 3),
-    //             Lexeme::invalid(3, 6),
-    //         ],
-    //     );
-    // }
-
-    #[test]
-    fn parses_semicolons() {
-        test_scanner(
-            "123;456",
-            vec![
-                (TokenType::Integer, TokenValue::Integer(123), 0, 3),
-                (TokenType::Semicolon, TokenValue::None, 3, 1),
-                (TokenType::Integer, TokenValue::Integer(456), 4, 3),
-            ],
-        );
-    }
-
-    #[test]
-    fn parses_struct() {
-        test_scanner("struct", vec![(TokenType::Struct, TokenValue::None, 0, 6)]);
-    }
-
-    fn test_scanner(input: &str, expected: Vec<(TokenType, TokenValue, usize, usize)>) {
-        let mut files = Files::default();
-        files.insert("test file", input);
-
-        let scanner = Scanner::new(&files);
-        let lexemes = scanner.parse();
-
-        let expected = expected
-            .into_iter()
-            .map(|(token_type, token_value, cursor, length)| {
-                Lexeme::valid("test file", token_type, token_value, cursor, length)
-            })
-            .collect::<Vec<_>>();
-
-        println!(
-            "Got:      {}",
-            lexemes
-                .iter()
-                .map(|lexeme| lexeme.to_string())
-                .collect::<Vec<_>>()
-                .join(" + ")
-        );
-        println!(
-            "Expected: {}",
-            expected
-                .iter()
-                .map(|lexeme| lexeme.to_string())
-                .collect::<Vec<_>>()
-                .join(" + ")
-        );
-
-        assert_eq!(lexemes, expected);
-    }
-}
diff --git a/src/transpiler/bend.rs b/src/transpiler/bend.rs
deleted file mode 100644
index 5b8de2f..0000000
--- a/src/transpiler/bend.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-use crate::parser::ast::{BinaryOperation, Expression, Statement, Symbol, Type, UnaryOperation};
-
-use super::Transpiler;
-
-pub struct BendTranspiler {}
-
-impl Transpiler for BendTranspiler {
-    fn transpile(symbol: &Symbol) -> String {
-        let mut output = String::new();
-
-        match symbol {
-            Symbol::Expression(expression) => {
-                output.push_str(&transpile_expression(expression));
-            }
-            Symbol::Statement(statement) => {
-                output.push_str(&transpile_statement(statement));
-            }
-            Symbol::Unknown(lexeme) => {
-                output.push_str(&format!("Unknown lexeme: {:?}", lexeme));
-            }
-            Symbol::Type(_) => {}
-        }
-
-        output
-    }
-}
-
-#[allow(clippy::only_used_in_recursion)]
-fn transpile_expression(expression: &Expression) -> String {
-    match expression {
-        Expression::Number(number) => number.to_string(),
-        Expression::String(string) => format!("\"{}\"", string),
-        Expression::Identifier(symbol) => symbol.clone(),
-        Expression::Binary(left, operation, right) => {
-            let left = transpile_expression(left);
-            let operation = match operation {
-                BinaryOperation::Plus => "+",
-                BinaryOperation::Minus => "-",
-                BinaryOperation::Times => "*",
-                BinaryOperation::Divide => "/",
-            };
-            let right = transpile_expression(right);
-            format!("{} {} {}", left, operation, right)
-        }
-        Expression::Grouping(expression) => {
-            format!("({})", transpile_expression(expression))
-        }
-        Expression::Assignment(identifier, expression) => {
-            let identifier = transpile_expression(identifier);
-            let expression = transpile_expression(expression);
-            format!("{} = {}", identifier, expression)
-        }
-        Expression::Unary(operation, expression) => {
-            let operation = match operation {
-                UnaryOperation::Negate => "-",
-                UnaryOperation::Inverse => "!",
-            };
-            let expression = transpile_expression(expression);
-            format!("{}{}", operation, expression)
-        }
-        Expression::StructInitializer(name, members) => {
-            let mut output = String::new();
-            output.push_str(&format!("{} {{\n", name));
-            for (member, expression) in members {
-                output.push_str(&format!(
-                    "{}: {},\n",
-                    member,
-                    transpile_expression(expression)
-                ));
-            }
-            output.push('}');
-            output
-        }
-    }
-}
-
-fn transpile_statement(statement: &Statement) -> String {
-    match statement {
-        Statement::Block(statements) => {
-            let mut output = String::new();
-            output.push_str("{\n");
-            for statement in statements {
-                output.push_str(&transpile_statement(statement));
-            }
-            output.push_str("}\n");
-            output
-        }
-        Statement::Expression(expression) => {
-            let expression = transpile_expression(expression);
-            format!("{};\n", expression)
-        }
-        Statement::Declaration(identifier, typing, expression) => {
-            let expression = transpile_expression(expression);
-            let typing = match typing {
-                Some(typing) => format!(": {}", transpile_type(typing)),
-                None => String::new(),
-            };
-            format!("let {}{} = {};\n", identifier, typing, expression)
-        }
-        Statement::Struct(name, members) => {
-            let mut output = String::new();
-            output.push_str(&format!("struct {} {{\n", name));
-            for (member, typing) in members {
-                output.push_str(&format!("{}: {};\n", member, transpile_type(typing)));
-            }
-            output.push_str("}\n");
-            output
-        }
-        Statement::Enum(name, members) => {
-            let mut output = String::new();
-            output.push_str(&format!("enum {} {{\n", name));
-            for member in members {
-                output.push_str(&format!("{},\n", member));
-            }
-            output.push_str("}\n");
-            output
-        }
-    }
-}
-
-fn transpile_type(typing: &Type) -> String {
-    match typing {
-        Type::Symbol(symbol) => symbol.clone(),
-        Type::Array(typing) => format!("{}[]", transpile_type(typing)),
-        Type::Tuple(members) => {
-            let mut output = String::new();
-            output.push('(');
-            for (member, typing) in members {
-                output.push_str(&format!("{}: {}, ", member, transpile_type(typing)));
-            }
-            output.push(')');
-            output
-        }
-    }
-}
diff --git a/src/transpiler/mod.rs b/src/transpiler/mod.rs
deleted file mode 100644
index b18bd05..0000000
--- a/src/transpiler/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use crate::parser::ast::Symbol;
-
-pub mod bend;
-
-pub trait Transpiler {
-    fn transpile(symbol: &Symbol) -> String;
-}

From a979be0a864a4863c0892cb69893321336ee05d6 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Sun, 27 Oct 2024 22:59:10 +0100
Subject: [PATCH 02/43] =?UTF-8?q?=F0=9F=9A=A7=20Rewrite=20in=20progress?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 Cargo.lock           | 389 ++++++++++++++++++++++++++++++++++++---
 Cargo.toml           |   4 +-
 src/lexer/mod.rs     | 420 +++++++++++++++++++++++++++++++++++++++++++
 src/lexer/token.rs   | 216 ++++++++++++++++++++++
 src/main.rs          |  27 ++-
 src/parser/ast.rs    |  39 ++++
 src/parser/lookup.rs |   1 +
 src/parser/mod.rs    |  27 +++
 8 files changed, 1094 insertions(+), 29 deletions(-)
 create mode 100644 src/lexer/mod.rs
 create mode 100644 src/lexer/token.rs
 create mode 100644 src/parser/ast.rs
 create mode 100644 src/parser/lookup.rs
 create mode 100644 src/parser/mod.rs

diff --git a/Cargo.lock b/Cargo.lock
index dbdb502..ae6ea9c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,21 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "addr2line"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.3"
@@ -12,27 +27,179 @@ dependencies = [
 ]
 
 [[package]]
-name = "anyhow"
-version = "1.0.86"
+name = "backtrace"
+version = "0.3.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
+checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a"
+dependencies = [
+ "addr2line",
+ "cc",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+]
 
 [[package]]
-name = "codespan-reporting"
-version = "0.11.1"
+name = "backtrace-ext"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+checksum = "537beee3be4a18fb023b570f80e3ae28003db9167a751266b259926e25539d50"
 dependencies = [
- "termcolor",
- "unicode-width",
+ "backtrace",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+
+[[package]]
+name = "cc"
+version = "1.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2e7962b54006dcfcc61cb72735f4d89bb97061dd6a7ed882ec6b8ee53714c6f"
+dependencies = [
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
+[[package]]
+name = "errno"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "gimli"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
+
+[[package]]
+name = "is_ci"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45"
+
+[[package]]
+name = "libc"
+version = "0.2.161"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+
 [[package]]
 name = "memchr"
 version = "2.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
 
+[[package]]
+name = "miette"
+version = "7.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4edc8853320c2a0dab800fbda86253c8938f6ea88510dc92c5f1ed20e794afc1"
+dependencies = [
+ "backtrace",
+ "backtrace-ext",
+ "cfg-if",
+ "miette-derive",
+ "owo-colors",
+ "supports-color",
+ "supports-hyperlinks",
+ "supports-unicode",
+ "terminal_size",
+ "textwrap",
+ "thiserror",
+ "unicode-width",
+]
+
+[[package]]
+name = "miette-derive"
+version = "7.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcf09caffaac8068c346b6df2a7fc27a177fd20b39421a39ce0a211bde679a6c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "object"
+version = "0.36.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aedf0a2d09c573ed1d8d85b30c119153926a2b36dce0ab28322c09a117a4683e"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "owo-colors"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb37767f6569cd834a413442455e0f066d0d522de8630436e2a1761d9726ba56"
+
+[[package]]
+name = "pretty_assertions"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d"
+dependencies = [
+ "diff",
+ "yansi",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
 [[package]]
 name = "regex"
 version = "1.10.4"
@@ -62,24 +229,131 @@ version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"
 
+[[package]]
+name = "rustc-demangle"
+version = "0.1.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
+
+[[package]]
+name = "rustix"
+version = "0.38.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "smawk"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
+
 [[package]]
 name = "som"
 version = "0.1.0"
 dependencies = [
- "anyhow",
- "codespan-reporting",
+ "miette",
+ "pretty_assertions",
  "regex",
 ]
 
 [[package]]
-name = "termcolor"
-version = "1.4.1"
+name = "supports-color"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8775305acf21c96926c900ad056abeef436701108518cf890020387236ac5a77"
+dependencies = [
+ "is_ci",
+]
+
+[[package]]
+name = "supports-hyperlinks"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c0a1e5168041f5f3ff68ff7d95dcb9c8749df29f6e7e89ada40dd4c9de404ee"
+
+[[package]]
+name = "supports-unicode"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7401a30af6cb5818bb64852270bb722533397edcfc7344954a38f420819ece2"
+
+[[package]]
+name = "syn"
+version = "2.0.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+checksum = "5023162dfcd14ef8f32034d8bcd4cc5ddc61ef7a247c024a33e24e1f24d21b56"
 dependencies = [
- "winapi-util",
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
 ]
 
+[[package]]
+name = "terminal_size"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7"
+dependencies = [
+ "rustix",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23d434d3f8967a09480fb04132ebe0a3e088c173e6d0ee7897abbdf4eab0f8b9"
+dependencies = [
+ "smawk",
+ "unicode-linebreak",
+ "unicode-width",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d11abd9594d9b38965ef50805c5e469ca9cc6f197f883f717e0269a3057b3d5"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae71770322cbd277e69d762a16c444af02aa0575ac0d174f0b9562d3b37f8602"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+
+[[package]]
+name = "unicode-linebreak"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
+
 [[package]]
 name = "unicode-width"
 version = "0.1.13"
@@ -87,12 +361,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
 
 [[package]]
-name = "winapi-util"
-version = "0.1.8"
+name = "windows-sys"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
 dependencies = [
- "windows-sys",
+ "windows-targets 0.48.5",
 ]
 
 [[package]]
@@ -101,7 +375,22 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
 ]
 
 [[package]]
@@ -110,28 +399,46 @@ version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
+ "windows_aarch64_gnullvm 0.52.5",
+ "windows_aarch64_msvc 0.52.5",
+ "windows_i686_gnu 0.52.5",
  "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_i686_msvc 0.52.5",
+ "windows_x86_64_gnu 0.52.5",
+ "windows_x86_64_gnullvm 0.52.5",
+ "windows_x86_64_msvc 0.52.5",
 ]
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.5"
@@ -144,26 +451,56 @@ version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
+
+[[package]]
+name = "yansi"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
diff --git a/Cargo.toml b/Cargo.toml
index 5f7eccc..84362f8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,6 +7,6 @@ authors = ["Somfic"]
 description = "The 'som' programming language"
 
 [dependencies]
-anyhow = "1.0"
-codespan-reporting = "0.11.1"
+miette = { version = "7.2.0", features = ["fancy"] }
+pretty_assertions = "1.4.1"
 regex = "1.10"
diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
new file mode 100644
index 0000000..69b0919
--- /dev/null
+++ b/src/lexer/mod.rs
@@ -0,0 +1,420 @@
+pub mod token;
+pub use token::*;
+
+use miette::{LabeledSpan, Result, SourceSpan};
+
+pub struct Lexer<'de> {
+    whole: &'de str,
+    remainder: &'de str,
+    byte_offset: usize,
+    peeked: Option<Result<Token<'de>, miette::Error>>,
+}
+
+impl<'de> Lexer<'de> {
+    pub fn new(input: &'de str) -> Self {
+        Self {
+            whole: input,
+            remainder: input,
+            byte_offset: 0,
+            peeked: None,
+        }
+    }
+
+    pub fn expect(
+        &mut self,
+        expected: TokenKind,
+        unexpected: &str,
+    ) -> Result<Token<'de>, miette::Error> {
+        match self.next() {
+            Some(Ok(token)) if expected == token.kind => Ok(token),
+            Some(Ok(token)) => Err(miette::miette! {
+                labels = vec![
+                    token.label(format!("Expected {} here", expected))
+                ],
+                help = format!("Expected {}, got {}", expected, token),
+                "{unexpected}",
+            }
+            .with_source_code(self.whole.to_string())),
+            Some(Err(e)) => Err(e),
+            None => Err(miette::miette! {
+                "unexpected end of input"
+            }),
+        }
+    }
+
+    pub fn expect_where(
+        &mut self,
+        mut check: impl FnMut(&Token<'de>) -> bool,
+        unexpected: &str,
+    ) -> Result<Token<'de>, miette::Error> {
+        match self.next() {
+            Some(Ok(token)) if check(&token) => Ok(token),
+            Some(Ok(token)) => Err(miette::miette! {
+                labels = vec![
+                    token.label("here")
+                ],
+                help = format!("Expected {token:?}"),
+                "{unexpected}",
+            }
+            .with_source_code(self.whole.to_string())),
+            Some(Err(e)) => Err(e),
+            None => Err(miette::miette! {
+                "unexpected end of input"
+            }),
+        }
+    }
+
+    pub fn peek(&mut self) -> Option<&Result<Token<'de>, miette::Error>> {
+        if self.peeked.is_some() {
+            return self.peeked.as_ref();
+        }
+
+        self.peeked = self.next();
+        self.peeked.as_ref()
+    }
+
+    fn parse_compound_operator(
+        &mut self,
+        single: TokenKind,
+        compound: TokenKind,
+        expected_char: char,
+    ) -> Result<(TokenKind, TokenValue<'de>)> {
+        if let Some(c) = self.remainder.chars().next() {
+            if c == expected_char {
+                self.remainder = &self.remainder[c.len_utf8()..];
+                self.byte_offset += c.len_utf8();
+                Ok((compound, TokenValue::None))
+            } else {
+                Ok((single, TokenValue::None))
+            }
+        } else {
+            Ok((single, TokenValue::None))
+        }
+    }
+}
+
+impl<'de> Iterator for Lexer<'de> {
+    type Item = Result<Token<'de>>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(next) = self.peeked.take() {
+            return Some(next);
+        }
+
+        let mut chars = self.remainder.chars();
+
+        let start_offset = self.byte_offset;
+
+        let c = chars.next()?;
+        self.remainder = chars.as_str();
+        self.byte_offset += c.len_utf8();
+
+        let kind: Result<(TokenKind, TokenValue<'de>)> = match c {
+            '(' => Ok((TokenKind::ParenOpen, TokenValue::None)),
+            ')' => Ok((TokenKind::ParenClose, TokenValue::None)),
+            '{' => Ok((TokenKind::CurlyOpen, TokenValue::None)),
+            '}' => Ok((TokenKind::CurlyClose, TokenValue::None)),
+            '[' => Ok((TokenKind::SquareOpen, TokenValue::None)),
+            ']' => Ok((TokenKind::SquareClose, TokenValue::None)),
+            ';' => Ok((TokenKind::Semicolon, TokenValue::None)),
+            ',' => Ok((TokenKind::Comma, TokenValue::None)),
+            '.' => Ok((TokenKind::Dot, TokenValue::None)),
+            '@' => Ok((TokenKind::At, TokenValue::None)),
+            '#' => Ok((TokenKind::Hash, TokenValue::None)),
+            '$' => Ok((TokenKind::Dollar, TokenValue::None)),
+            '|' => Ok((TokenKind::Pipe, TokenValue::None)),
+            '^' => Ok((TokenKind::Caret, TokenValue::None)),
+            '~' => Ok((TokenKind::Tilde, TokenValue::None)),
+            '?' => Ok((TokenKind::Question, TokenValue::None)),
+            ':' => Ok((TokenKind::Colon, TokenValue::None)),
+            '-' => Ok((TokenKind::Minus, TokenValue::None)),
+            '+' => Ok((TokenKind::Plus, TokenValue::None)),
+            '*' => Ok((TokenKind::Star, TokenValue::None)),
+            '/' => Ok((TokenKind::Slash, TokenValue::None)),
+            '%' => Ok((TokenKind::Percent, TokenValue::None)),
+            '=' => self.parse_compound_operator(TokenKind::Equal, TokenKind::Equality, '='),
+            '!' => self.parse_compound_operator(TokenKind::Not, TokenKind::Inequality, '='),
+            '<' => self.parse_compound_operator(TokenKind::LessThan, TokenKind::LessThanOrEqual, '='),
+            '>' => self.parse_compound_operator(TokenKind::GreaterThan, TokenKind::GreaterThanOrEqual, '='),
+            'a'..='z' | 'A'..='Z' | '_' => {
+                // Identifiers
+                let mut ident = String::new();
+                ident.push(c);
+                while let Some(c) = self.remainder.chars().next() {
+                    if c.is_alphanumeric() || c == '_' {
+                        ident.push(c);
+                        self.remainder = &self.remainder[c.len_utf8()..];
+                        self.byte_offset += c.len_utf8();
+                    } else {
+                        break;
+                    }
+                }
+
+                match ident.as_str() {
+                    "if" => Ok((TokenKind::If, TokenValue::None)),
+                    "else" => Ok((TokenKind::Else, TokenValue::None)),
+                    "fn" => Ok((TokenKind::Function, TokenValue::None)),
+                    "true" => Ok((TokenKind::Boolean, TokenValue::Boolean(true))),
+                    "false" =>Ok((TokenKind::Boolean, TokenValue::Boolean(false))),
+                    ident => Ok((TokenKind::Identifier, TokenValue::Identifier(ident.to_string().into()))),
+                }
+            }
+            // Whole and decimal numbers
+            '0'..='9' => {
+                let mut number = String::new();
+                number.push(c);
+                while let Some(c) = self.remainder.chars().next() {
+                    if c.is_digit(10) || c == '.' {
+                        number.push(c);
+                        self.remainder = &self.remainder[c.len_utf8()..];
+                        self.byte_offset += c.len_utf8();
+                    } else {
+                        break;
+                    }
+                }
+
+                if let Ok(num) = number.parse::<i64>() {
+                    Ok((TokenKind::Integer, TokenValue::Integer(num)))
+                } else if let Ok(num) = number.parse::<f64>() {
+                     Ok((TokenKind::Decimal, TokenValue::Decimal(num)))
+                } else {
+                    Err(miette::miette! {
+                        labels = vec![
+                            LabeledSpan::at(self.byte_offset - number.len()..self.byte_offset, "this number")
+                        ],
+                        "invalid number"
+                    }
+                    .with_source_code(self.whole.to_string()))
+                }
+            }
+            '"' => {
+                let mut string = String::new();
+                while let Some(c) = self.remainder.chars().next() {
+                    if c == '"' {
+                        self.remainder = &self.remainder[c.len_utf8()..];
+                        self.byte_offset += c.len_utf8();
+                        break;
+                    } else {
+                        string.push(c);
+                        self.remainder = &self.remainder[c.len_utf8()..];
+                        self.byte_offset += c.len_utf8();
+                    }
+                }
+
+                Ok((TokenKind::String, TokenValue::String(string.into())))
+            }
+            '\'' => {
+                let c = self.remainder.chars().next()?;
+                self.remainder = &self.remainder[c.len_utf8()..];
+                self.byte_offset += c.len_utf8();
+
+                if self.remainder.chars().next()? == '\'' {
+                    self.remainder = &self.remainder[c.len_utf8()..];
+                    self.byte_offset += c.len_utf8();
+                    Ok((TokenKind::Character, TokenValue::Character(c)))
+                } else {
+                    Err(miette::miette! {
+                        labels = vec![
+                            LabeledSpan::at(self.byte_offset..self.byte_offset + c.len_utf8(), "this character")
+                        ],
+                        "expected closing single quote"
+                    }
+                    .with_source_code(self.whole.to_string()))
+                }
+            }
+            ' ' | '\r' | '\t' | '\n' => {
+                return self.next();
+            }
+            _ => {
+                Err(miette::miette! {
+                    labels = vec![
+                        LabeledSpan::at(self.byte_offset - c.len_utf8()..self.byte_offset, "this character")
+                    ],
+                    "unexpected character '{c}' in input"
+                }
+                .with_source_code(self.whole.to_string()))
+            }
+        };
+
+        let byte_length = self
+            .byte_offset
+            .checked_sub(start_offset)
+            .expect("byte_offset should never be less than start_offset");
+
+        Some(kind.map(|(kind, value)| Token {
+            kind,
+            value,
+            span: SourceSpan::new(start_offset.into(), byte_length),
+        }))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn punctuation() {
+        test_tokens_eq(
+            Lexer::new(".,@#$~?:-|+*/^% () [] {}"),
+            vec![
+                (TokenKind::Dot, TokenValue::None),
+                (TokenKind::Comma, TokenValue::None),
+                (TokenKind::At, TokenValue::None),
+                (TokenKind::Hash, TokenValue::None),
+                (TokenKind::Dollar, TokenValue::None),
+                (TokenKind::Tilde, TokenValue::None),
+                (TokenKind::Question, TokenValue::None),
+                (TokenKind::Colon, TokenValue::None),
+                (TokenKind::Minus, TokenValue::None),
+                (TokenKind::Pipe, TokenValue::None),
+                (TokenKind::Plus, TokenValue::None),
+                (TokenKind::Star, TokenValue::None),
+                (TokenKind::Slash, TokenValue::None),
+                (TokenKind::Caret, TokenValue::None),
+                (TokenKind::Percent, TokenValue::None),
+                (TokenKind::ParenOpen, TokenValue::None),
+                (TokenKind::ParenClose, TokenValue::None),
+                (TokenKind::SquareOpen, TokenValue::None),
+                (TokenKind::SquareClose, TokenValue::None),
+                (TokenKind::CurlyOpen, TokenValue::None),
+                (TokenKind::CurlyClose, TokenValue::None),
+            ],
+        );
+    }
+
+    #[test]
+    fn comparison() {
+        test_tokens_eq(
+            Lexer::new("= != == < > <= >="),
+            vec![
+                (TokenKind::Equal, TokenValue::None),
+                (TokenKind::Inequality, TokenValue::None),
+                (TokenKind::Equality, TokenValue::None),
+                (TokenKind::LessThan, TokenValue::None),
+                (TokenKind::GreaterThan, TokenValue::None),
+                (TokenKind::LessThanOrEqual, TokenValue::None),
+                (TokenKind::GreaterThanOrEqual, TokenValue::None),
+            ],
+        );
+    }
+
+    #[test]
+    fn keywords() {
+        test_tokens_eq(
+            Lexer::new("if else"),
+            vec![
+                (TokenKind::If, TokenValue::None),
+                (TokenKind::Else, TokenValue::None),
+            ],
+        );
+    }
+
+    #[test]
+    fn numbers() {
+        test_tokens_eq(
+            Lexer::new("1 1.0 0.1"),
+            vec![
+                (TokenKind::Integer, TokenValue::Integer(1)),
+                (TokenKind::Decimal, TokenValue::Decimal(1.0)),
+                (TokenKind::Decimal, TokenValue::Decimal(0.1)),
+            ],
+        );
+    }
+
+    #[test]
+    fn strings() {
+        test_tokens_eq(
+            Lexer::new("\"foo\" \"bar\" \"baz\""),
+            vec![
+                (TokenKind::String, TokenValue::String("foo".into())),
+                (TokenKind::String, TokenValue::String("bar".into())),
+                (TokenKind::String, TokenValue::String("baz".into())),
+            ],
+        );
+    }
+
+    #[test]
+    fn characters() {
+        test_tokens_eq(
+            Lexer::new("'a' 'b' 'c'"),
+            vec![
+                (TokenKind::Character, TokenValue::Character('a')),
+                (TokenKind::Character, TokenValue::Character('b')),
+                (TokenKind::Character, TokenValue::Character('c')),
+            ],
+        );
+    }
+
+    #[test]
+    fn booleans() {
+        test_tokens_eq(
+            Lexer::new("true false"),
+            vec![
+                (TokenKind::Boolean, TokenValue::Boolean(true)),
+                (TokenKind::Boolean, TokenValue::Boolean(false)),
+            ],
+        );
+    }
+
+    #[test]
+    fn identifiers() {
+        test_tokens_eq(
+            Lexer::new("foo bar baz"),
+            vec![
+                (TokenKind::Identifier, TokenValue::Identifier("foo".into())),
+                (TokenKind::Identifier, TokenValue::Identifier("bar".into())),
+                (TokenKind::Identifier, TokenValue::Identifier("baz".into())),
+            ],
+        );
+    }
+
+    #[test]
+    fn program() {
+        let program = "
+            fn main(self) ~ number {
+                print(\"{self.name} ({self.age}) is purring\");
+            };
+        ";
+
+        let lexer = Lexer::new(program);
+        let expected_tokens = vec![
+            (TokenKind::Function, TokenValue::None),
+            (TokenKind::Identifier, TokenValue::Identifier("main".into())),
+            (TokenKind::ParenOpen, TokenValue::None),
+            (TokenKind::Identifier, TokenValue::Identifier("self".into())),
+            (TokenKind::ParenClose, TokenValue::None),
+            (TokenKind::Tilde, TokenValue::None),
+            (
+                TokenKind::Identifier,
+                TokenValue::Identifier("number".into()),
+            ),
+            (TokenKind::CurlyOpen, TokenValue::None),
+            (
+                TokenKind::Identifier,
+                TokenValue::Identifier("print".into()),
+            ),
+            (TokenKind::ParenOpen, TokenValue::None),
+            (
+                TokenKind::String,
+                TokenValue::String("{self.name} ({self.age}) is purring".into()),
+            ),
+            (TokenKind::ParenClose, TokenValue::None),
+            (TokenKind::Semicolon, TokenValue::None),
+            (TokenKind::CurlyClose, TokenValue::None),
+            (TokenKind::Semicolon, TokenValue::None),
+        ];
+
+        test_tokens_eq(lexer, expected_tokens);
+    }
+
+    fn test_tokens_eq(lexer: Lexer<'_>, tokens: Vec<(TokenKind, TokenValue<'_>)>) {
+        let actual_tokens = lexer
+            .map(Result::unwrap)
+            .map(|x| (x.kind, x.value))
+            .collect::<Vec<_>>();
+
+        assert_eq!(actual_tokens, tokens);
+    }
+}
diff --git a/src/lexer/token.rs b/src/lexer/token.rs
new file mode 100644
index 0000000..b2dbbab
--- /dev/null
+++ b/src/lexer/token.rs
@@ -0,0 +1,216 @@
+use std::{borrow::Cow, fmt::Display, hash::Hash};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Token<'de> {
+    pub kind: TokenKind,
+    pub value: TokenValue<'de>,
+    pub span: miette::SourceSpan,
+}
+
+impl<'de> Token<'de> {
+    pub fn label(&self, text: impl Into<String>) -> miette::LabeledSpan {
+        miette::LabeledSpan::at(self.span, text.into())
+    }
+}
+
+impl Display for Token<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.value {
+            TokenValue::None => write!(f, "{}", self.kind),
+            value => write!(f, "{}: {}", self.kind, value),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum TokenValue<'de> {
+    None,
+    Boolean(bool),
+    Integer(i64),
+    Decimal(f64),
+    String(Cow<'de, str>),
+    Character(char),
+    Identifier(Cow<'de, str>),
+}
+
+impl Display for TokenValue<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TokenValue::None => write!(f, ""),
+            TokenValue::Boolean(value) => write!(f, "{}", value),
+            TokenValue::Integer(value) => write!(f, "{}", value),
+            TokenValue::Decimal(value) => write!(f, "{}", value),
+            TokenValue::String(value) => write!(f, "{}", value),
+            TokenValue::Character(value) => write!(f, "{}", value),
+            TokenValue::Identifier(value) => write!(f, "{}", value),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub enum TokenKind {
+    /// A token that should be ignored. This is used for whitespace, comments, etc.
+    Ignore,
+
+    /// The opening of an indentation level.
+    IndentationOpen,
+    /// The closing of an indentation level.
+    IndentationClose,
+
+    /// An opening parenthesis; `(`.
+    ParenOpen,
+    /// A closing parenthesis; `)`.
+    ParenClose,
+    /// An opening curly brace; `{`.
+    CurlyOpen,
+    /// A closing curly brace; `}`.
+    CurlyClose,
+    /// An opening square bracket; `[`.
+    SquareOpen,
+    /// A closing square bracket; `]`.
+    SquareClose,
+
+    /// A comma; `,`.
+    Comma,
+    /// A dot; `.`.
+    Dot,
+    /// A colon; `:`.
+    Colon,
+    /// A semicolon; `;`.
+    Semicolon,
+
+    /// A plus sign; `+`;
+    Plus,
+    /// A minus sign; `-`.
+    Minus,
+    /// A forward slash; `/`.
+    Slash,
+    /// An asterisk; `*`.
+    Star,
+    /// A percent sign; `%`.
+    Percent,
+
+    /// An equals sign; `=`.
+    Equal,
+    /// A negetion sign; `!`.
+    Not,
+    /// A less-than sign; `<`.
+    LessThan,
+    /// A greater-than sign; `>`.
+    GreaterThan,
+    /// A less-than-or-equal sign; `<=`.
+    LessThanOrEqual,
+    /// A greater-than-or-equal sign; `>=`.
+    GreaterThanOrEqual,
+    /// An equality sign; `==`.
+    Equality,
+    /// An inequality sign; `!=`.
+    Inequality,
+
+    /// An at sign; `@`.
+    At,
+    /// A hash sign; `#`.
+    Hash,
+    /// A dollar sign; `$`.
+    Dollar,
+    /// A tilde sign; `~`.
+    Tilde,
+    /// A question mark; `?`.
+    Question,
+    /// A pipe; `|`.
+    Pipe,
+    /// An caret; `^`.
+    Caret,
+
+    /// An if keyword; `if`.
+    If,
+    /// An else keyword; `else`.
+    Else,
+
+    /// A while keyword; `while`.
+    While,
+    /// A for keyword; `for`.
+    For,
+
+    /// A var keyword; `var`.
+    Let,
+
+    /// A function keyword; `fn`.
+    Function,
+    /// A return keyword; `return`.
+    Return,
+
+    /// A boolean; `true`, `false`.
+    Boolean,
+    /// A number; `42`, `12`, `-7`.
+    Integer,
+    /// A decimal; `3.14`, `2.718`, `-1.0`.
+    Decimal,
+    /// A string; `"foo"`, `"bar"`, `"baz"`.
+    String,
+    /// A character; `'a'`, `'b'`, `'c'`.
+    Character,
+
+    /// An identifying name; `foo`, `bar`, `baz`.
+    Identifier,
+
+    /// A struct keyword; `struct`.
+    Struct,
+    /// A enum keyword; `enum`.
+    Enum,
+}
+
+impl Display for TokenKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TokenKind::Ignore => write!(f, ""),
+            TokenKind::IndentationOpen => write!(f, "opening indentation level"),
+            TokenKind::IndentationClose => write!(f, "closing indentation level"),
+            TokenKind::ParenOpen => write!(f, "`(`"),
+            TokenKind::ParenClose => write!(f, "`)`"),
+            TokenKind::CurlyOpen => write!(f, "`{{`"),
+            TokenKind::CurlyClose => write!(f, "`}}`"),
+            TokenKind::SquareOpen => write!(f, "`[`"),
+            TokenKind::SquareClose => write!(f, "`]`"),
+            TokenKind::Comma => write!(f, "`,`"),
+            TokenKind::Dot => write!(f, "`.`"),
+            TokenKind::Colon => write!(f, "`:`"),
+            TokenKind::Semicolon => write!(f, "`;`"),
+            TokenKind::Plus => write!(f, "`+`"),
+            TokenKind::Minus => write!(f, "`-`"),
+            TokenKind::Slash => write!(f, "`/`"),
+            TokenKind::Star => write!(f, "`*`"),
+            TokenKind::Equal => write!(f, "`=`"),
+            TokenKind::Not => write!(f, "`!`"),
+            TokenKind::LessThan => write!(f, "`<`"),
+            TokenKind::GreaterThan => write!(f, "`>`"),
+            TokenKind::LessThanOrEqual => write!(f, "`<=`"),
+            TokenKind::GreaterThanOrEqual => write!(f, "`>=`"),
+            TokenKind::Equality => write!(f, "`==`"),
+            TokenKind::Inequality => write!(f, "`!=`"),
+            TokenKind::If => write!(f, "`if`"),
+            TokenKind::Else => write!(f, "`else`"),
+            TokenKind::While => write!(f, "`while`"),
+            TokenKind::For => write!(f, "`for`"),
+            TokenKind::Let => write!(f, "`let`"),
+            TokenKind::Function => write!(f, "`fn`"),
+            TokenKind::Return => write!(f, "`return`"),
+            TokenKind::Boolean => write!(f, "a boolean value"),
+            TokenKind::Integer => write!(f, "an integer value"),
+            TokenKind::Decimal => write!(f, "a decimal value"),
+            TokenKind::String => write!(f, "a string value"),
+            TokenKind::Character => write!(f, "a character value"),
+            TokenKind::Identifier => write!(f, "an identifier"),
+            TokenKind::Struct => write!(f, "`struct`"),
+            TokenKind::Enum => write!(f, "`enum`"),
+            TokenKind::Percent => write!(f, "`%`"),
+            TokenKind::At => write!(f, "`@`"),
+            TokenKind::Hash => write!(f, "`#`"),
+            TokenKind::Dollar => write!(f, "`$`"),
+            TokenKind::Tilde => write!(f, "`~`"),
+            TokenKind::Question => write!(f, "`?`"),
+            TokenKind::Pipe => write!(f, "`|`"),
+            TokenKind::Caret => write!(f, "`^`"),
+        }
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index e7a11a9..4023f9c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,3 +1,28 @@
+use lexer::Lexer;
+use miette::LabeledSpan;
+use parser::Parser;
+
+pub mod lexer;
+pub mod parser;
+
 fn main() {
-    println!("Hello, world!");
+    let input = "2 + 3 * 2;";
+
+    let mut lexer = Lexer::new(input);
+    let tokens = lexer.collect::<Vec<_>>();
+
+    for token in &tokens {
+        println!("{:?}", token);
+    }
+
+    let mut parser = Parser::new(input);
+    let symbol = match parser.parse() {
+        Ok(symbol) => symbol,
+        Err(err) => {
+            println!("{:?}", err);
+            return;
+        }
+    };
+
+    println!("{:?}", symbol);
 }
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
new file mode 100644
index 0000000..cd68ad8
--- /dev/null
+++ b/src/parser/ast.rs
@@ -0,0 +1,39 @@
+use std::borrow::Cow;
+
+#[derive(Debug)]
+pub enum Symbol<'de> {
+    Statement(Statement<'de>),
+    Expression(Expression<'de>),
+}
+
+#[derive(Debug)]
+pub enum Statement<'de> {
+    Block(Vec<Statement<'de>>),
+    Expression(Expression<'de>),
+}
+
+#[derive(Debug)]
+pub enum Expression<'de> {
+    Primitive(Primitive<'de>),
+    Binary {
+        operator: BinaryOperator,
+        left: Box<Expression<'de>>,
+        right: Box<Expression<'de>>,
+    },
+}
+
+#[derive(Debug)]
+pub enum Primitive<'de> {
+    Integer(i64),
+    Float(f64),
+    String(Cow<'de, str>),
+    Boolean(bool),
+}
+
+#[derive(Debug)]
+pub enum BinaryOperator {
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/src/parser/lookup.rs
@@ -0,0 +1 @@
+
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
new file mode 100644
index 0000000..593f4a0
--- /dev/null
+++ b/src/parser/mod.rs
@@ -0,0 +1,27 @@
+use crate::lexer::{Lexer, Token, TokenKind};
+use ast::{Statement, Symbol};
+use miette::{Context, Error, Result};
+use std::{borrow::Cow, collections::HashMap, os::macos};
+
+pub mod ast;
+pub mod lookup;
+
+pub struct Parser<'de> {
+    source: &'de str,
+    lexer: Lexer<'de>,
+}
+
+impl<'de> Parser<'de> {
+    pub fn new(input: &'de str) -> Self {
+        Parser {
+            source: input,
+            lexer: Lexer::new(input),
+        }
+    }
+
+    pub fn parse(&mut self) -> Result<Symbol<'de>> {
+        self.lexer.expect(TokenKind::String, "expected backtick")?;
+
+        Ok(Symbol::Statement(Statement::Block(vec![])))
+    }
+}

From 59e75446cdf3d0dfd168d8b430304e22bebbfc3a Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Mon, 28 Oct 2024 09:05:36 +0100
Subject: [PATCH 03/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/lexer/mod.rs         |  24 +++++++--
 src/main.rs              |   2 +-
 src/parser/expression.rs |  28 ++++++++++
 src/parser/lookup.rs     | 109 +++++++++++++++++++++++++++++++++++++++
 src/parser/mod.rs        |   9 ++--
 5 files changed, 163 insertions(+), 9 deletions(-)
 create mode 100644 src/parser/expression.rs

diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
index 69b0919..a2e7d34 100644
--- a/src/lexer/mod.rs
+++ b/src/lexer/mod.rs
@@ -31,14 +31,19 @@ impl<'de> Lexer<'de> {
                 labels = vec![
                     token.label(format!("Expected {} here", expected))
                 ],
-                help = format!("Expected {}, got {}", expected, token),
+                help = format!("Expected {}, got {}", expected, token.kind),
                 "{unexpected}",
             }
             .with_source_code(self.whole.to_string())),
             Some(Err(e)) => Err(e),
             None => Err(miette::miette! {
-                "unexpected end of input"
-            }),
+                labels = vec![
+                    LabeledSpan::at_offset(self.byte_offset - 1, "Expected more source code here")
+                ],
+                help = "More source code was expected, but none was found",
+                "{unexpected}",
+            }
+            .with_source_code(self.whole.to_string())),
         }
     }
 
@@ -59,11 +64,20 @@ impl<'de> Lexer<'de> {
             .with_source_code(self.whole.to_string())),
             Some(Err(e)) => Err(e),
             None => Err(miette::miette! {
-                "unexpected end of input"
-            }),
+                labels = vec![
+                    LabeledSpan::at_offset(self.byte_offset - 1, "Expected more source code here")
+                ],
+                help = "More source code was expected, but none was found",
+                "{unexpected}",
+            }
+            .with_source_code(self.whole.to_string())),
         }
     }
 
+    pub fn expect_any(&mut self, unexpected: &str) -> Result<Token<'de>, miette::Error> {
+        self.expect_where(|_| true, unexpected)
+    }
+
     pub fn peek(&mut self) -> Option<&Result<Token<'de>, miette::Error>> {
         if self.peeked.is_some() {
             return self.peeked.as_ref();
diff --git a/src/main.rs b/src/main.rs
index 4023f9c..a5d4974 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,7 +6,7 @@ pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "2 + 3 * 2;";
+    let input = "1";
 
     let mut lexer = Lexer::new(input);
     let tokens = lexer.collect::<Vec<_>>();
diff --git a/src/parser/expression.rs b/src/parser/expression.rs
new file mode 100644
index 0000000..9bbddb7
--- /dev/null
+++ b/src/parser/expression.rs
@@ -0,0 +1,28 @@
+use miette::Result;
+
+use super::{ast::Expression, Parser};
+
+pub fn parse<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
+    let token = parser.lexer.expect_any("expected an expression")?;
+    let handler = parser.lookup.expression_lookup.get(&token.kind).ok_or(
+        miette::miette! {
+            labels = vec![token.label("expected a new expression")],
+            help = format!("cannot parse {} into a new expression", token.kind),
+            "expected a new expression, found {}", token.kind
+        }
+        .with_source_code(parser.source.to_string()),
+    )?;
+
+    let mut lhs = handler(parser)?;
+
+    loop {
+        let peeked = match parser.lexer.peek().cloned() {
+            Some(token) => token,
+            None => break,
+        }?;
+
+        let bp = parser.lookup.binding_power_lookup.get(&peeked.kind);
+    }
+
+    todo!()
+}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 8b13789..b206da7 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -1 +1,110 @@
+use crate::lexer::TokenKind;
+use miette::Result;
+use std::collections::HashMap;
 
+use super::{
+    ast::{Expression, Statement},
+    Parser,
+};
+
+#[derive(Debug, PartialEq, PartialOrd)]
+pub enum BindingPower {
+    None = 0,
+    Comma = 1,
+    Assignment = 2,
+    Logical = 3,
+    Relational = 4,
+    Additive = 5,
+    Multiplicative = 6,
+    Unary = 7,
+    Call = 8,
+    Member = 9,
+    Primary = 10,
+}
+
+// pub type TypeHandler<'de> = fn(&mut Parser<'de>) -> Result<(Type, usize), Error<'de>>;
+// pub type LeftTypeHandler<'de> =
+//     fn(&'de Parser<'de>, usize, Type, &BindingPower) -> Result<(Type, usize), Error<'de>>;
+pub type StatementHandler<'de> = fn(&mut Parser<'de>) -> Result<Statement<'de>>;
+pub type ExpressionHandler<'de> = fn(&mut Parser<'de>) -> Result<Expression<'de>>;
+pub type LeftExpressionHandler<'de> =
+    fn(&mut Parser<'de>, Expression, BindingPower) -> Result<Expression<'de>>;
+
+pub struct Lookup<'de> {
+    pub statement_lookup: HashMap<TokenKind, StatementHandler<'de>>,
+    pub expression_lookup: HashMap<TokenKind, ExpressionHandler<'de>>,
+    pub left_expression_lookup: HashMap<TokenKind, LeftExpressionHandler<'de>>,
+    // pub type_lookup: HashMap<TokenKind, TypeHandler<'de>>,
+    // pub left_type_lookup: HashMap<TokenKind, LeftTypeHandler<'de>>,
+    pub binding_power_lookup: HashMap<TokenKind, BindingPower>,
+}
+
+impl<'a> Lookup<'a> {
+    pub(crate) fn add_statement_handler(
+        &mut self,
+        token: TokenKind,
+        handler: StatementHandler<'a>,
+    ) {
+        if self.statement_lookup.contains_key(&token) {
+            panic!("Token already has a statement handler");
+        }
+
+        self.statement_lookup.insert(token, handler);
+    }
+
+    pub(crate) fn add_expression_handler(
+        &mut self,
+        token: TokenKind,
+        handler: ExpressionHandler<'a>,
+    ) {
+        if self.expression_lookup.contains_key(&token) {
+            panic!("Token already has an expression handler");
+        }
+
+        self.expression_lookup.insert(token, handler);
+    }
+
+    pub(crate) fn add_left_expression_handler(
+        &mut self,
+        token: TokenKind,
+        binding_power: BindingPower,
+        handler: LeftExpressionHandler<'a>,
+    ) {
+        if self.binding_power_lookup.contains_key(&token) {
+            panic!("Token already has a binding power");
+        }
+
+        self.left_expression_lookup.insert(token.clone(), handler);
+        self.binding_power_lookup.insert(token, binding_power);
+    }
+
+    // pub(crate) fn add_type_handler(&mut self, token: TokenType, handler: TypeHandler<'a>) {
+    //     if self.type_lookup.contains_key(&token) {
+    //         panic!("Token already has a type handler");
+    //     }
+
+    //     self.type_lookup.insert(token, handler);
+    // }
+
+    // #[allow(dead_code)]
+    // pub(crate) fn add_left_type_handler(&mut self, token: TokenType, handler: LeftTypeHandler<'a>) {
+    //     if self.left_type_lookup.contains_key(&token) {
+    //         panic!("Token already has a left type handler");
+    //     }
+
+    //     self.left_type_lookup.insert(token, handler);
+    // }
+}
+
+impl<'a> Default for Lookup<'a> {
+    fn default() -> Self {
+        Lookup {
+            statement_lookup: HashMap::new(),
+            expression_lookup: HashMap::new(),
+            left_expression_lookup: HashMap::new(),
+            binding_power_lookup: HashMap::new(),
+            // type_lookup: HashMap::new(),
+            // left_type_lookup: HashMap::new(),
+        }
+    }
+}
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index 593f4a0..f780752 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -1,14 +1,17 @@
 use crate::lexer::{Lexer, Token, TokenKind};
 use ast::{Statement, Symbol};
+use lookup::Lookup;
 use miette::{Context, Error, Result};
 use std::{borrow::Cow, collections::HashMap, os::macos};
 
 pub mod ast;
+pub mod expression;
 pub mod lookup;
 
 pub struct Parser<'de> {
     source: &'de str,
     lexer: Lexer<'de>,
+    lookup: Lookup<'de>,
 }
 
 impl<'de> Parser<'de> {
@@ -16,12 +19,12 @@ impl<'de> Parser<'de> {
         Parser {
             source: input,
             lexer: Lexer::new(input),
+            lookup: Lookup::default(),
         }
     }
 
     pub fn parse(&mut self) -> Result<Symbol<'de>> {
-        self.lexer.expect(TokenKind::String, "expected backtick")?;
-
-        Ok(Symbol::Statement(Statement::Block(vec![])))
+        expression::parse(self)?;
+        todo!()
     }
 }

From f17c1d34f9b2ab70f0bbccf46f80e3808eefd846 Mon Sep 17 00:00:00 2001
From: Lucas de Jong <lucas.dejong@cofano.nl>
Date: Mon, 28 Oct 2024 16:01:50 +0100
Subject: [PATCH 04/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/lexer/mod.rs         | 40 ++++++++++++++++++---
 src/main.rs              |  9 +----
 src/parser/expression.rs | 75 +++++++++++++++++++++++++++++++++++-----
 src/parser/lookup.rs     | 38 +++++++++++---------
 src/parser/mod.rs        |  8 ++---
 src/parser/statement.rs  | 13 +++++++
 6 files changed, 141 insertions(+), 42 deletions(-)
 create mode 100644 src/parser/statement.rs

diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
index a2e7d34..95587cf 100644
--- a/src/lexer/mod.rs
+++ b/src/lexer/mod.rs
@@ -38,11 +38,12 @@ impl<'de> Lexer<'de> {
             Some(Err(e)) => Err(e),
             None => Err(miette::miette! {
                 labels = vec![
-                    LabeledSpan::at_offset(self.byte_offset - 1, "Expected more source code here")
+                    LabeledSpan::at_offset(self.byte_offset - 1, format!("Expected {} here", expected))
                 ],
-                help = "More source code was expected, but none was found",
-                "{unexpected}",
+                help = format!("{} was expected, but no more code was found", expected),
+                "unexpected end of input",
             }
+            .wrap_err(unexpected.to_string())
             .with_source_code(self.whole.to_string())),
         }
     }
@@ -67,7 +68,7 @@ impl<'de> Lexer<'de> {
                 labels = vec![
                     LabeledSpan::at_offset(self.byte_offset - 1, "Expected more source code here")
                 ],
-                help = "More source code was expected, but none was found",
+                help = "more source code was expected, but none was found",
                 "{unexpected}",
             }
             .with_source_code(self.whole.to_string())),
@@ -423,6 +424,37 @@ mod test {
         test_tokens_eq(lexer, expected_tokens);
     }
 
+    #[test]
+    fn peeking() {
+        let input = "1 2 3";
+
+        let mut lexer = Lexer::new(input);
+
+        let first = lexer.peek().unwrap().as_ref().unwrap();
+        assert_eq!(first.kind, TokenKind::Integer);
+        assert_eq!(first.value, TokenValue::Integer(1));
+
+        let first = lexer.next().unwrap().unwrap();
+        assert_eq!(first.kind, TokenKind::Integer);
+        assert_eq!(first.value, TokenValue::Integer(1));
+
+        let second = lexer.peek().unwrap().as_ref().unwrap();
+        assert_eq!(second.kind, TokenKind::Integer);
+        assert_eq!(second.value, TokenValue::Integer(2));
+
+        let second = lexer.next().unwrap().unwrap();
+        assert_eq!(second.kind, TokenKind::Integer);
+        assert_eq!(second.value, TokenValue::Integer(2));
+
+        let third = lexer.peek().unwrap().as_ref().unwrap();
+        assert_eq!(third.kind, TokenKind::Integer);
+        assert_eq!(third.value, TokenValue::Integer(3));
+
+        let third = lexer.next().unwrap().unwrap();
+        assert_eq!(third.kind, TokenKind::Integer);
+        assert_eq!(third.value, TokenValue::Integer(3));
+    }
+
     fn test_tokens_eq(lexer: Lexer<'_>, tokens: Vec<(TokenKind, TokenValue<'_>)>) {
         let actual_tokens = lexer
             .map(Result::unwrap)
diff --git a/src/main.rs b/src/main.rs
index a5d4974..ebbe624 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,14 +6,7 @@ pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "1";
-
-    let mut lexer = Lexer::new(input);
-    let tokens = lexer.collect::<Vec<_>>();
-
-    for token in &tokens {
-        println!("{:?}", token);
-    }
+    let input = "1 + 1111;";
 
     let mut parser = Parser::new(input);
     let symbol = match parser.parse() {
diff --git a/src/parser/expression.rs b/src/parser/expression.rs
index 9bbddb7..8864b46 100644
--- a/src/parser/expression.rs
+++ b/src/parser/expression.rs
@@ -1,9 +1,32 @@
 use miette::Result;
 
-use super::{ast::Expression, Parser};
+use crate::{
+    lexer::{TokenKind, TokenValue},
+    parser::lookup::BindingPower,
+};
+
+use super::{
+    ast::{BinaryOperator, Expression, Primitive},
+    lookup::Lookup,
+    Parser,
+};
+
+pub fn parse<'de>(
+    parser: &mut Parser<'de>,
+    binding_power: BindingPower,
+) -> Result<Expression<'de>> {
+    let token = match parser.lexer.peek().as_ref() {
+        Some(Ok(token)) => token,
+        Some(Err(err)) => return Err(miette::miette!(err.to_string())), // FIXME: better error handling
+        None => {
+            return Err(miette::miette! {
+                help = "expected a new expression",
+                "expected a new expression, found EOF"
+            }
+            .with_source_code(parser.source.to_string()))
+        }
+    };
 
-pub fn parse<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
-    let token = parser.lexer.expect_any("expected an expression")?;
     let handler = parser.lookup.expression_lookup.get(&token.kind).ok_or(
         miette::miette! {
             labels = vec![token.label("expected a new expression")],
@@ -15,14 +38,48 @@ pub fn parse<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
 
     let mut lhs = handler(parser)?;
 
-    loop {
-        let peeked = match parser.lexer.peek().cloned() {
-            Some(token) => token,
+    while let Some(token) = parser.lexer.peek() {
+        let token = match token {
+            Ok(token) => token,
+            Err(err) => return Err(miette::miette!(err.to_string())), // FIXME: better error handling
+        };
+
+        let token_binding_power = {
+            let binding_power_lookup = parser.lookup.binding_power_lookup.clone();
+            binding_power_lookup
+                .get(&token.kind)
+                .unwrap_or(&BindingPower::None)
+                .clone()
+        };
+
+        if binding_power > token_binding_power {
+            break;
+        }
+
+        let handler = match parser.lookup.left_expression_lookup.get(&token.kind) {
+            Some(handler) => handler,
             None => break,
-        }?;
+        };
+
+        parser.lexer.next();
 
-        let bp = parser.lookup.binding_power_lookup.get(&peeked.kind);
+        lhs = handler(parser, lhs, token_binding_power)?;
     }
 
-    todo!()
+    Ok(lhs)
+}
+
+pub fn add_handlers<'de>(lookup: &'de mut Lookup<'de>) {
+    lookup.add_left_expression_handler(
+        TokenKind::Plus,
+        BindingPower::Additive,
+        |parser: &mut Parser<'_>, lhs: Expression<'_>, bp| -> Result<Expression<'_>> {
+            let rhs = parse(parser, bp)?;
+            Ok(Expression::Binary {
+                operator: BinaryOperator::Add,
+                left: Box::new(lhs),
+                right: Box::new(rhs),
+            })
+        },
+    );
 }
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index b206da7..086f926 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -4,10 +4,10 @@ use std::collections::HashMap;
 
 use super::{
     ast::{Expression, Statement},
-    Parser,
+    expression, Parser,
 };
 
-#[derive(Debug, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
 pub enum BindingPower {
     None = 0,
     Comma = 1,
@@ -25,10 +25,10 @@ pub enum BindingPower {
 // pub type TypeHandler<'de> = fn(&mut Parser<'de>) -> Result<(Type, usize), Error<'de>>;
 // pub type LeftTypeHandler<'de> =
 //     fn(&'de Parser<'de>, usize, Type, &BindingPower) -> Result<(Type, usize), Error<'de>>;
-pub type StatementHandler<'de> = fn(&mut Parser<'de>) -> Result<Statement<'de>>;
-pub type ExpressionHandler<'de> = fn(&mut Parser<'de>) -> Result<Expression<'de>>;
+pub type StatementHandler<'de> = fn(&'de mut Parser<'de>) -> Result<Statement<'de>>;
+pub type ExpressionHandler<'de> = fn(&'de mut Parser<'de>) -> Result<Expression<'de>>;
 pub type LeftExpressionHandler<'de> =
-    fn(&mut Parser<'de>, Expression, BindingPower) -> Result<Expression<'de>>;
+    fn(&'de mut Parser<'de>, Expression, BindingPower) -> Result<Expression<'de>>;
 
 pub struct Lookup<'de> {
     pub statement_lookup: HashMap<TokenKind, StatementHandler<'de>>,
@@ -39,11 +39,11 @@ pub struct Lookup<'de> {
     pub binding_power_lookup: HashMap<TokenKind, BindingPower>,
 }
 
-impl<'a> Lookup<'a> {
+impl<'de> Lookup<'de> {
     pub(crate) fn add_statement_handler(
-        &mut self,
+        &'de mut self,
         token: TokenKind,
-        handler: StatementHandler<'a>,
+        handler: StatementHandler<'de>,
     ) {
         if self.statement_lookup.contains_key(&token) {
             panic!("Token already has a statement handler");
@@ -53,9 +53,9 @@ impl<'a> Lookup<'a> {
     }
 
     pub(crate) fn add_expression_handler(
-        &mut self,
+        &'de mut self,
         token: TokenKind,
-        handler: ExpressionHandler<'a>,
+        handler: ExpressionHandler<'de>,
     ) {
         if self.expression_lookup.contains_key(&token) {
             panic!("Token already has an expression handler");
@@ -65,10 +65,10 @@ impl<'a> Lookup<'a> {
     }
 
     pub(crate) fn add_left_expression_handler(
-        &mut self,
+        &'de mut self,
         token: TokenKind,
         binding_power: BindingPower,
-        handler: LeftExpressionHandler<'a>,
+        handler: LeftExpressionHandler<'de>,
     ) {
         if self.binding_power_lookup.contains_key(&token) {
             panic!("Token already has a binding power");
@@ -78,7 +78,7 @@ impl<'a> Lookup<'a> {
         self.binding_power_lookup.insert(token, binding_power);
     }
 
-    // pub(crate) fn add_type_handler(&mut self, token: TokenType, handler: TypeHandler<'a>) {
+    // pub(crate) fn add_type_handler(&mut self, token: TokenType, handler: TypeHandler<'de>) {
     //     if self.type_lookup.contains_key(&token) {
     //         panic!("Token already has a type handler");
     //     }
@@ -87,7 +87,7 @@ impl<'a> Lookup<'a> {
     // }
 
     // #[allow(dead_code)]
-    // pub(crate) fn add_left_type_handler(&mut self, token: TokenType, handler: LeftTypeHandler<'a>) {
+    // pub(crate) fn add_left_type_handler(&mut self, token: TokenType, handler: LeftTypeHandler<'de>) {
     //     if self.left_type_lookup.contains_key(&token) {
     //         panic!("Token already has a left type handler");
     //     }
@@ -96,15 +96,19 @@ impl<'a> Lookup<'a> {
     // }
 }
 
-impl<'a> Default for Lookup<'a> {
+impl<'de> Default for Lookup<'de> {
     fn default() -> Self {
-        Lookup {
+        let mut lookup = Lookup {
             statement_lookup: HashMap::new(),
             expression_lookup: HashMap::new(),
             left_expression_lookup: HashMap::new(),
             binding_power_lookup: HashMap::new(),
             // type_lookup: HashMap::new(),
             // left_type_lookup: HashMap::new(),
-        }
+        };
+
+        expression::add_handlers(&mut lookup);
+
+        lookup
     }
 }
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index f780752..d503412 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -1,12 +1,13 @@
 use crate::lexer::{Lexer, Token, TokenKind};
 use ast::{Statement, Symbol};
-use lookup::Lookup;
+use lookup::{BindingPower, Lookup};
 use miette::{Context, Error, Result};
-use std::{borrow::Cow, collections::HashMap, os::macos};
+use std::{borrow::Cow, collections::HashMap};
 
 pub mod ast;
 pub mod expression;
 pub mod lookup;
+pub mod statement;
 
 pub struct Parser<'de> {
     source: &'de str,
@@ -24,7 +25,6 @@ impl<'de> Parser<'de> {
     }
 
     pub fn parse(&mut self) -> Result<Symbol<'de>> {
-        expression::parse(self)?;
-        todo!()
+        Ok(Symbol::Statement(statement::parse(self)?))
     }
 }
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
new file mode 100644
index 0000000..a46a6b5
--- /dev/null
+++ b/src/parser/statement.rs
@@ -0,0 +1,13 @@
+use crate::lexer::TokenKind;
+
+use super::{ast::Statement, expression, lookup::BindingPower, Parser};
+use miette::{Context, Result};
+
+pub fn parse<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
+    let expression = expression::parse(parser, BindingPower::None)?;
+    parser
+        .lexer
+        .expect(TokenKind::Semicolon, "expected a semicolon")?;
+
+    Ok(Statement::Expression(expression))
+}

From 8853e48cdb87e17fcfed33fca0ea9907308e5332 Mon Sep 17 00:00:00 2001
From: Lucas de Jong <lucas.dejong@cofano.nl>
Date: Mon, 28 Oct 2024 16:32:41 +0100
Subject: [PATCH 05/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/parser/expression.rs | 22 ++++----------
 src/parser/lookup.rs     | 64 ++++++++++++++++++++++++++++++----------
 2 files changed, 53 insertions(+), 33 deletions(-)

diff --git a/src/parser/expression.rs b/src/parser/expression.rs
index 8864b46..790e30d 100644
--- a/src/parser/expression.rs
+++ b/src/parser/expression.rs
@@ -35,10 +35,11 @@ pub fn parse<'de>(
         }
         .with_source_code(parser.source.to_string()),
     )?;
-
     let mut lhs = handler(parser)?;
 
-    while let Some(token) = parser.lexer.peek() {
+    let mut next_token = parser.lexer.peek();
+
+    while let Some(token) = next_token {
         let token = match token {
             Ok(token) => token,
             Err(err) => return Err(miette::miette!(err.to_string())), // FIXME: better error handling
@@ -64,22 +65,9 @@ pub fn parse<'de>(
         parser.lexer.next();
 
         lhs = handler(parser, lhs, token_binding_power)?;
+
+        next_token = parser.lexer.peek();
     }
 
     Ok(lhs)
 }
-
-pub fn add_handlers<'de>(lookup: &'de mut Lookup<'de>) {
-    lookup.add_left_expression_handler(
-        TokenKind::Plus,
-        BindingPower::Additive,
-        |parser: &mut Parser<'_>, lhs: Expression<'_>, bp| -> Result<Expression<'_>> {
-            let rhs = parse(parser, bp)?;
-            Ok(Expression::Binary {
-                operator: BinaryOperator::Add,
-                left: Box::new(lhs),
-                right: Box::new(rhs),
-            })
-        },
-    );
-}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 086f926..3d6dd4b 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -1,9 +1,9 @@
-use crate::lexer::TokenKind;
+use crate::lexer::{TokenKind, TokenValue};
 use miette::Result;
 use std::collections::HashMap;
 
 use super::{
-    ast::{Expression, Statement},
+    ast::{BinaryOperator, Expression, Primitive, Statement},
     expression, Parser,
 };
 
@@ -25,10 +25,10 @@ pub enum BindingPower {
 // pub type TypeHandler<'de> = fn(&mut Parser<'de>) -> Result<(Type, usize), Error<'de>>;
 // pub type LeftTypeHandler<'de> =
 //     fn(&'de Parser<'de>, usize, Type, &BindingPower) -> Result<(Type, usize), Error<'de>>;
-pub type StatementHandler<'de> = fn(&'de mut Parser<'de>) -> Result<Statement<'de>>;
-pub type ExpressionHandler<'de> = fn(&'de mut Parser<'de>) -> Result<Expression<'de>>;
+pub type StatementHandler<'de> = fn(&mut Parser<'de>) -> Result<Statement<'de>>;
+pub type ExpressionHandler<'de> = fn(&mut Parser<'de>) -> Result<Expression<'de>>;
 pub type LeftExpressionHandler<'de> =
-    fn(&'de mut Parser<'de>, Expression, BindingPower) -> Result<Expression<'de>>;
+    fn(&mut Parser<'de>, Expression, BindingPower) -> Result<Expression<'de>>;
 
 pub struct Lookup<'de> {
     pub statement_lookup: HashMap<TokenKind, StatementHandler<'de>>,
@@ -41,41 +41,44 @@ pub struct Lookup<'de> {
 
 impl<'de> Lookup<'de> {
     pub(crate) fn add_statement_handler(
-        &'de mut self,
+        mut self,
         token: TokenKind,
         handler: StatementHandler<'de>,
-    ) {
+    ) -> Self {
         if self.statement_lookup.contains_key(&token) {
             panic!("Token already has a statement handler");
         }
 
         self.statement_lookup.insert(token, handler);
+        self
     }
 
     pub(crate) fn add_expression_handler(
-        &'de mut self,
+        mut self,
         token: TokenKind,
         handler: ExpressionHandler<'de>,
-    ) {
+    ) -> Self {
         if self.expression_lookup.contains_key(&token) {
             panic!("Token already has an expression handler");
         }
 
         self.expression_lookup.insert(token, handler);
+        self
     }
 
     pub(crate) fn add_left_expression_handler(
-        &'de mut self,
+        mut self,
         token: TokenKind,
         binding_power: BindingPower,
         handler: LeftExpressionHandler<'de>,
-    ) {
+    ) -> Self {
         if self.binding_power_lookup.contains_key(&token) {
             panic!("Token already has a binding power");
         }
 
         self.left_expression_lookup.insert(token.clone(), handler);
         self.binding_power_lookup.insert(token, binding_power);
+        self
     }
 
     // pub(crate) fn add_type_handler(&mut self, token: TokenType, handler: TypeHandler<'de>) {
@@ -98,17 +101,46 @@ impl<'de> Lookup<'de> {
 
 impl<'de> Default for Lookup<'de> {
     fn default() -> Self {
-        let mut lookup = Lookup {
+        Lookup {
             statement_lookup: HashMap::new(),
             expression_lookup: HashMap::new(),
             left_expression_lookup: HashMap::new(),
             binding_power_lookup: HashMap::new(),
             // type_lookup: HashMap::new(),
             // left_type_lookup: HashMap::new(),
-        };
+        }
+        .add_expression_handler(TokenKind::Integer, integer)
+        .add_left_expression_handler(TokenKind::Plus, BindingPower::Additive, addition)
+    }
+}
 
-        expression::add_handlers(&mut lookup);
+fn integer<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
+    let token = parser
+        .lexer
+        .expect(TokenKind::Integer, "expected an integer")?;
 
-        lookup
-    }
+    let value = match token.value {
+        TokenValue::Integer(v) => v,
+        _ => unreachable!(),
+    };
+
+    Ok(Expression::Primitive(Primitive::Integer(value)))
+}
+
+fn addition<'de>(
+    parser: &mut Parser,
+    lhs: Expression,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let token = parser
+        .lexer
+        .expect(TokenKind::Plus, "expected a plus sign")?;
+
+    let rhs = expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::Add,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
 }

From e92bb2c895fa5578998f650423ebbc56558ba2f9 Mon Sep 17 00:00:00 2001
From: Lucas de Jong <lucas.dejong@cofano.nl>
Date: Mon, 28 Oct 2024 16:34:24 +0100
Subject: [PATCH 06/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/parser/lookup.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 3d6dd4b..b5343d8 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -28,7 +28,7 @@ pub enum BindingPower {
 pub type StatementHandler<'de> = fn(&mut Parser<'de>) -> Result<Statement<'de>>;
 pub type ExpressionHandler<'de> = fn(&mut Parser<'de>) -> Result<Expression<'de>>;
 pub type LeftExpressionHandler<'de> =
-    fn(&mut Parser<'de>, Expression, BindingPower) -> Result<Expression<'de>>;
+    fn(&mut Parser<'de>, Expression<'de>, BindingPower) -> Result<Expression<'de>>;
 
 pub struct Lookup<'de> {
     pub statement_lookup: HashMap<TokenKind, StatementHandler<'de>>,
@@ -128,14 +128,10 @@ fn integer<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
 }
 
 fn addition<'de>(
-    parser: &mut Parser,
-    lhs: Expression,
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let token = parser
-        .lexer
-        .expect(TokenKind::Plus, "expected a plus sign")?;
-
     let rhs = expression::parse(parser, bp)?;
 
     Ok(Expression::Binary {

From a6a6a78f65ef11f944a51ce9f61e7ed196faea13 Mon Sep 17 00:00:00 2001
From: Lucas de Jong <lucas.dejong@cofano.nl>
Date: Mon, 28 Oct 2024 17:00:52 +0100
Subject: [PATCH 07/43] =?UTF-8?q?=F0=9F=9A=A7=20wip?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/lexer/mod.rs         |  8 ++++----
 src/main.rs              |  2 +-
 src/parser/ast.rs        |  2 +-
 src/parser/expression.rs | 10 +++++-----
 src/parser/lookup.rs     | 33 +++++++++++++++++++++++++++++++++
 src/parser/statement.rs  |  7 ++++---
 6 files changed, 48 insertions(+), 14 deletions(-)

diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
index 95587cf..4acaa68 100644
--- a/src/lexer/mod.rs
+++ b/src/lexer/mod.rs
@@ -29,9 +29,9 @@ impl<'de> Lexer<'de> {
             Some(Ok(token)) if expected == token.kind => Ok(token),
             Some(Ok(token)) => Err(miette::miette! {
                 labels = vec![
-                    token.label(format!("Expected {} here", expected))
+                    token.label(format!("expected {} here", expected))
                 ],
-                help = format!("Expected {}, got {}", expected, token.kind),
+                help = format!("expected {}, got {} instead", expected, token.kind),
                 "{unexpected}",
             }
             .with_source_code(self.whole.to_string())),
@@ -59,14 +59,14 @@ impl<'de> Lexer<'de> {
                 labels = vec![
                     token.label("here")
                 ],
-                help = format!("Expected {token:?}"),
+                help = format!("expected {token:?}"),
                 "{unexpected}",
             }
             .with_source_code(self.whole.to_string())),
             Some(Err(e)) => Err(e),
             None => Err(miette::miette! {
                 labels = vec![
-                    LabeledSpan::at_offset(self.byte_offset - 1, "Expected more source code here")
+                    LabeledSpan::at_offset(self.byte_offset - 1, "expected more source code here")
                 ],
                 help = "more source code was expected, but none was found",
                 "{unexpected}",
diff --git a/src/main.rs b/src/main.rs
index ebbe624..ce27db3 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,7 +6,7 @@ pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "1 + 1111;";
+    let input = "1 * 2 + 3;";
 
     let mut parser = Parser::new(input);
     let symbol = match parser.parse() {
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index cd68ad8..00df1ca 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -25,7 +25,7 @@ pub enum Expression<'de> {
 #[derive(Debug)]
 pub enum Primitive<'de> {
     Integer(i64),
-    Float(f64),
+    Decimal(f64),
     String(Cow<'de, str>),
     Boolean(bool),
 }
diff --git a/src/parser/expression.rs b/src/parser/expression.rs
index 790e30d..0c1031a 100644
--- a/src/parser/expression.rs
+++ b/src/parser/expression.rs
@@ -20,8 +20,8 @@ pub fn parse<'de>(
         Some(Err(err)) => return Err(miette::miette!(err.to_string())), // FIXME: better error handling
         None => {
             return Err(miette::miette! {
-                help = "expected a new expression",
-                "expected a new expression, found EOF"
+                help = "expected an expression",
+                "expected an expression"
             }
             .with_source_code(parser.source.to_string()))
         }
@@ -29,9 +29,9 @@ pub fn parse<'de>(
 
     let handler = parser.lookup.expression_lookup.get(&token.kind).ok_or(
         miette::miette! {
-            labels = vec![token.label("expected a new expression")],
-            help = format!("cannot parse {} into a new expression", token.kind),
-            "expected a new expression, found {}", token.kind
+            labels = vec![token.label("expected an expression")],
+            help = format!("{} is not an expression", token.kind),
+            "expected an expression, found {}", token.kind
         }
         .with_source_code(parser.source.to_string()),
     )?;
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index b5343d8..7c92578 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -110,7 +110,13 @@ impl<'de> Default for Lookup<'de> {
             // left_type_lookup: HashMap::new(),
         }
         .add_expression_handler(TokenKind::Integer, integer)
+        .add_expression_handler(TokenKind::Decimal, decimal)
         .add_left_expression_handler(TokenKind::Plus, BindingPower::Additive, addition)
+        .add_left_expression_handler(
+            TokenKind::Star,
+            BindingPower::Multiplicative,
+            multiplication,
+        )
     }
 }
 
@@ -127,6 +133,19 @@ fn integer<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
     Ok(Expression::Primitive(Primitive::Integer(value)))
 }
 
+fn decimal<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
+    let token = parser
+        .lexer
+        .expect(TokenKind::Decimal, "expected a decimal")?;
+
+    let value = match token.value {
+        TokenValue::Decimal(v) => v,
+        _ => unreachable!(),
+    };
+
+    Ok(Expression::Primitive(Primitive::Decimal(value)))
+}
+
 fn addition<'de>(
     parser: &mut Parser<'de>,
     lhs: Expression<'de>,
@@ -140,3 +159,17 @@ fn addition<'de>(
         right: Box::new(rhs),
     })
 }
+
+fn multiplication<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::Multiply,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index a46a6b5..89da7a2 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -5,9 +5,10 @@ use miette::{Context, Result};
 
 pub fn parse<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
     let expression = expression::parse(parser, BindingPower::None)?;
-    parser
-        .lexer
-        .expect(TokenKind::Semicolon, "expected a semicolon")?;
+    parser.lexer.expect(
+        TokenKind::Semicolon,
+        "expected a semicolon at the end of an expression",
+    )?;
 
     Ok(Statement::Expression(expression))
 }

From d2629bffef9164a2ea210ed57d2e2ac72001ebf1 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Tue, 29 Oct 2024 02:02:42 +0100
Subject: [PATCH 08/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 readme.md                                     |  4 +-
 src/main.rs                                   |  2 +-
 src/parser/ast.rs                             |  1 +
 src/parser/expression/binary.rs               | 62 ++++++++++++++
 .../{expression.rs => expression/mod.rs}      |  3 +
 src/parser/expression/primitive.rs            | 34 ++++++++
 src/parser/lookup.rs                          | 83 +++++++------------
 7 files changed, 135 insertions(+), 54 deletions(-)
 create mode 100644 src/parser/expression/binary.rs
 rename src/parser/{expression.rs => expression/mod.rs} (98%)
 create mode 100644 src/parser/expression/primitive.rs

diff --git a/readme.md b/readme.md
index 052d3ec..e63be55 100644
--- a/readme.md
+++ b/readme.md
@@ -25,10 +25,10 @@ code purrer for cat:
 ```
 
 ```rust
-comp Name: 
+struct Name: 
   name ~ string;
 
-comp Age: age ~ number;
+struct Age: age ~ number;
 
 enum tail_length:
   short,
diff --git a/src/main.rs b/src/main.rs
index ce27db3..2dedd0a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,7 +6,7 @@ pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "1 * 2 + 3;";
+    let input = "1 / ( 1 * 1 )\n";
 
     let mut parser = Parser::new(input);
     let symbol = match parser.parse() {
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index 00df1ca..f38f7b5 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -20,6 +20,7 @@ pub enum Expression<'de> {
         left: Box<Expression<'de>>,
         right: Box<Expression<'de>>,
     },
+    Group(Box<Expression<'de>>),
 }
 
 #[derive(Debug)]
diff --git a/src/parser/expression/binary.rs b/src/parser/expression/binary.rs
new file mode 100644
index 0000000..e91d6a0
--- /dev/null
+++ b/src/parser/expression/binary.rs
@@ -0,0 +1,62 @@
+use crate::parser::{
+    ast::{BinaryOperator, Expression},
+    lookup::BindingPower,
+    Parser,
+};
+use miette::Result;
+
+pub fn addition<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::Add,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
+
+pub fn multiplication<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::Multiply,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
+
+pub fn subtraction<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::Subtract,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
+
+pub fn division<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::Divide,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
diff --git a/src/parser/expression.rs b/src/parser/expression/mod.rs
similarity index 98%
rename from src/parser/expression.rs
rename to src/parser/expression/mod.rs
index 0c1031a..a913bcb 100644
--- a/src/parser/expression.rs
+++ b/src/parser/expression/mod.rs
@@ -11,6 +11,9 @@ use super::{
     Parser,
 };
 
+pub mod binary;
+pub mod primitive;
+
 pub fn parse<'de>(
     parser: &mut Parser<'de>,
     binding_power: BindingPower,
diff --git a/src/parser/expression/primitive.rs b/src/parser/expression/primitive.rs
new file mode 100644
index 0000000..70971df
--- /dev/null
+++ b/src/parser/expression/primitive.rs
@@ -0,0 +1,34 @@
+use crate::{
+    lexer::{TokenKind, TokenValue},
+    parser::{
+        ast::{Expression, Primitive},
+        Parser,
+    },
+};
+use miette::Result;
+
+pub fn integer<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
+    let token = parser
+        .lexer
+        .expect(TokenKind::Integer, "expected an integer")?;
+
+    let value = match token.value {
+        TokenValue::Integer(v) => v,
+        _ => unreachable!(),
+    };
+
+    Ok(Expression::Primitive(Primitive::Integer(value)))
+}
+
+pub fn decimal<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
+    let token = parser
+        .lexer
+        .expect(TokenKind::Decimal, "expected a decimal")?;
+
+    let value = match token.value {
+        TokenValue::Decimal(v) => v,
+        _ => unreachable!(),
+    };
+
+    Ok(Expression::Primitive(Primitive::Decimal(value)))
+}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 7c92578..8d3740e 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -109,67 +109,48 @@ impl<'de> Default for Lookup<'de> {
             // type_lookup: HashMap::new(),
             // left_type_lookup: HashMap::new(),
         }
-        .add_expression_handler(TokenKind::Integer, integer)
-        .add_expression_handler(TokenKind::Decimal, decimal)
-        .add_left_expression_handler(TokenKind::Plus, BindingPower::Additive, addition)
+        .add_expression_handler(TokenKind::Integer, expression::primitive::integer)
+        .add_expression_handler(TokenKind::Decimal, expression::primitive::decimal)
+        .add_expression_handler(TokenKind::ParenOpen, group)
+        .add_expression_handler(TokenKind::If, if_)
+        .add_left_expression_handler(
+            TokenKind::Plus,
+            BindingPower::Additive,
+            expression::binary::addition,
+        )
+        .add_left_expression_handler(
+            TokenKind::Minus,
+            BindingPower::Additive,
+            expression::binary::subtraction,
+        )
         .add_left_expression_handler(
             TokenKind::Star,
             BindingPower::Multiplicative,
-            multiplication,
+            expression::binary::multiplication,
+        )
+        .add_left_expression_handler(
+            TokenKind::Slash,
+            BindingPower::Multiplicative,
+            expression::binary::division,
         )
     }
 }
 
-fn integer<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
-    let token = parser
-        .lexer
-        .expect(TokenKind::Integer, "expected an integer")?;
+fn if_<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
+    parser.lexer.expect(TokenKind::If, "expected an if")?;
+    let condition = expression::parse(parser, BindingPower::None)?;
 
-    let value = match token.value {
-        TokenValue::Integer(v) => v,
-        _ => unreachable!(),
-    };
-
-    Ok(Expression::Primitive(Primitive::Integer(value)))
+    todo!()
 }
 
-fn decimal<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
-    let token = parser
+fn group<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
+    parser
         .lexer
-        .expect(TokenKind::Decimal, "expected a decimal")?;
-
-    let value = match token.value {
-        TokenValue::Decimal(v) => v,
-        _ => unreachable!(),
-    };
-
-    Ok(Expression::Primitive(Primitive::Decimal(value)))
-}
-
-fn addition<'de>(
-    parser: &mut Parser<'de>,
-    lhs: Expression<'de>,
-    bp: BindingPower,
-) -> Result<Expression<'de>> {
-    let rhs = expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::Add,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
-}
+        .expect(TokenKind::ParenOpen, "expected a left parenthesis")?;
+    let expression = expression::parse(parser, BindingPower::None)?;
+    parser
+        .lexer
+        .expect(TokenKind::ParenClose, "expected a right parenthesis")?;
 
-fn multiplication<'de>(
-    parser: &mut Parser<'de>,
-    lhs: Expression<'de>,
-    bp: BindingPower,
-) -> Result<Expression<'de>> {
-    let rhs = expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::Multiply,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    Ok(Expression::Group(Box::new(expression)))
 }

From 8af81f82da64b2ea7c38df53c1bfa583674f3d57 Mon Sep 17 00:00:00 2001
From: Lucas de Jong <lucas.dejong@cofano.nl>
Date: Tue, 29 Oct 2024 16:20:48 +0100
Subject: [PATCH 09/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/lexer/token.rs              |   6 ++
 src/main.rs                     |   2 +-
 src/parser/ast.rs               |  19 +++++
 src/parser/expression/binary.rs | 126 ++++++++++++++++++++++++++++++++
 src/parser/expression/mod.rs    |   1 +
 src/parser/expression/unary.rs  |  33 +++++++++
 src/parser/lookup.rs            |  47 ++++++++++++
 7 files changed, 233 insertions(+), 1 deletion(-)
 create mode 100644 src/parser/expression/unary.rs

diff --git a/src/lexer/token.rs b/src/lexer/token.rs
index b2dbbab..fb2043c 100644
--- a/src/lexer/token.rs
+++ b/src/lexer/token.rs
@@ -106,6 +106,10 @@ pub enum TokenKind {
     Equality,
     /// An inequality sign; `!=`.
     Inequality,
+    /// An and sign; `&&`.
+    And,
+    /// An or sign; `||`.
+    Or,
 
     /// An at sign; `@`.
     At,
@@ -211,6 +215,8 @@ impl Display for TokenKind {
             TokenKind::Question => write!(f, "`?`"),
             TokenKind::Pipe => write!(f, "`|`"),
             TokenKind::Caret => write!(f, "`^`"),
+            TokenKind::And => todo!("`&&`"),
+            TokenKind::Or => todo!("`||`"),
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 2dedd0a..cb0ab2f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,7 +6,7 @@ pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "1 / ( 1 * 1 )\n";
+    let input = "2 == 12;\n";
 
     let mut parser = Parser::new(input);
     let symbol = match parser.parse() {
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index f38f7b5..38948ac 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -20,6 +20,10 @@ pub enum Expression<'de> {
         left: Box<Expression<'de>>,
         right: Box<Expression<'de>>,
     },
+    Unary {
+        operator: UnaryOperator,
+        operand: Box<Expression<'de>>,
+    },
     Group(Box<Expression<'de>>),
 }
 
@@ -37,4 +41,19 @@ pub enum BinaryOperator {
     Subtract,
     Multiply,
     Divide,
+    Modulo,
+    Equal,
+    NotEqual,
+    LessThan,
+    LessThanOrEqual,
+    GreaterThan,
+    GreaterThanOrEqual,
+    And,
+    Or,
+}
+
+#[derive(Debug)]
+pub enum UnaryOperator {
+    Negate,
+    Negative,
 }
diff --git a/src/parser/expression/binary.rs b/src/parser/expression/binary.rs
index e91d6a0..f312c58 100644
--- a/src/parser/expression/binary.rs
+++ b/src/parser/expression/binary.rs
@@ -60,3 +60,129 @@ pub fn division<'de>(
         right: Box::new(rhs),
     })
 }
+
+pub fn modulo<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::Modulo,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
+
+pub fn equal<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::Equal,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
+
+pub fn not_equal<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::NotEqual,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
+
+pub fn less_than<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::LessThan,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
+
+pub fn less_than_or_equal<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::LessThanOrEqual,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
+
+pub fn greater_than<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::GreaterThan,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
+
+pub fn greater_than_or_equal<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::GreaterThanOrEqual,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
+
+pub fn and<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::And,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
+
+pub fn or<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    let rhs = crate::parser::expression::parse(parser, bp)?;
+
+    Ok(Expression::Binary {
+        operator: BinaryOperator::Or,
+        left: Box::new(lhs),
+        right: Box::new(rhs),
+    })
+}
diff --git a/src/parser/expression/mod.rs b/src/parser/expression/mod.rs
index a913bcb..f169758 100644
--- a/src/parser/expression/mod.rs
+++ b/src/parser/expression/mod.rs
@@ -13,6 +13,7 @@ use super::{
 
 pub mod binary;
 pub mod primitive;
+pub mod unary;
 
 pub fn parse<'de>(
     parser: &mut Parser<'de>,
diff --git a/src/parser/expression/unary.rs b/src/parser/expression/unary.rs
new file mode 100644
index 0000000..c5de31f
--- /dev/null
+++ b/src/parser/expression/unary.rs
@@ -0,0 +1,33 @@
+use crate::{
+    lexer::TokenKind,
+    parser::{
+        ast::{Expression, UnaryOperator},
+        lookup::BindingPower,
+        Parser,
+    },
+};
+use miette::Result;
+
+pub fn negate<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::Not, "expected a negate operator")?;
+    let expression = crate::parser::expression::parse(parser, BindingPower::None)?;
+
+    Ok(Expression::Unary {
+        operator: UnaryOperator::Negate,
+        operand: Box::new(expression),
+    })
+}
+
+pub fn negative<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::Minus, "expected a negative operator")?;
+    let expression = crate::parser::expression::parse(parser, BindingPower::None)?;
+
+    Ok(Expression::Unary {
+        operator: UnaryOperator::Negative,
+        operand: Box::new(expression),
+    })
+}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 8d3740e..d6146f4 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -113,6 +113,8 @@ impl<'de> Default for Lookup<'de> {
         .add_expression_handler(TokenKind::Decimal, expression::primitive::decimal)
         .add_expression_handler(TokenKind::ParenOpen, group)
         .add_expression_handler(TokenKind::If, if_)
+        .add_expression_handler(TokenKind::Not, expression::unary::negate)
+        .add_expression_handler(TokenKind::Minus, expression::unary::negative)
         .add_left_expression_handler(
             TokenKind::Plus,
             BindingPower::Additive,
@@ -133,6 +135,51 @@ impl<'de> Default for Lookup<'de> {
             BindingPower::Multiplicative,
             expression::binary::division,
         )
+        .add_left_expression_handler(
+            TokenKind::Equality,
+            BindingPower::Assignment,
+            expression::binary::equal,
+        )
+        .add_left_expression_handler(
+            TokenKind::Inequality,
+            BindingPower::Assignment,
+            expression::binary::not_equal,
+        )
+        .add_left_expression_handler(
+            TokenKind::LessThan,
+            BindingPower::Relational,
+            expression::binary::less_than,
+        )
+        .add_left_expression_handler(
+            TokenKind::LessThanOrEqual,
+            BindingPower::Relational,
+            expression::binary::less_than_or_equal,
+        )
+        .add_left_expression_handler(
+            TokenKind::GreaterThan,
+            BindingPower::Relational,
+            expression::binary::greater_than,
+        )
+        .add_left_expression_handler(
+            TokenKind::GreaterThanOrEqual,
+            BindingPower::Relational,
+            expression::binary::greater_than_or_equal,
+        )
+        .add_left_expression_handler(
+            TokenKind::Percent,
+            BindingPower::Multiplicative,
+            expression::binary::modulo,
+        )
+        .add_left_expression_handler(
+            TokenKind::And,
+            BindingPower::Relational,
+            expression::binary::and,
+        )
+        .add_left_expression_handler(
+            TokenKind::Or,
+            BindingPower::Relational,
+            expression::binary::or,
+        )
     }
 }
 

From 9a2d40b4762ce82abecf2ed2fc0872f8f42ae6d7 Mon Sep 17 00:00:00 2001
From: Lucas de Jong <lucas.dejong@cofano.nl>
Date: Tue, 29 Oct 2024 16:29:04 +0100
Subject: [PATCH 10/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs                     |   2 +-
 src/parser/ast.rs               |   4 +-
 src/parser/expression/binary.rs | 109 +++++++-------------------------
 3 files changed, 26 insertions(+), 89 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index cb0ab2f..658d850 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,7 +6,7 @@ pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "2 == 12;\n";
+    let input = "2 == 2 % 12;\n";
 
     let mut parser = Parser::new(input);
     let symbol = match parser.parse() {
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index 38948ac..85a32a5 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -42,8 +42,8 @@ pub enum BinaryOperator {
     Multiply,
     Divide,
     Modulo,
-    Equal,
-    NotEqual,
+    Equality,
+    Inequality,
     LessThan,
     LessThanOrEqual,
     GreaterThan,
diff --git a/src/parser/expression/binary.rs b/src/parser/expression/binary.rs
index f312c58..b1b2cb8 100644
--- a/src/parser/expression/binary.rs
+++ b/src/parser/expression/binary.rs
@@ -5,32 +5,35 @@ use crate::parser::{
 };
 use miette::Result;
 
-pub fn addition<'de>(
+pub fn parse_binary_expression<'de>(
     parser: &mut Parser<'de>,
     lhs: Expression<'de>,
     bp: BindingPower,
+    operator: BinaryOperator,
 ) -> Result<Expression<'de>> {
     let rhs = crate::parser::expression::parse(parser, bp)?;
 
     Ok(Expression::Binary {
-        operator: BinaryOperator::Add,
+        operator,
         left: Box::new(lhs),
         right: Box::new(rhs),
     })
 }
 
-pub fn multiplication<'de>(
+pub fn addition<'de>(
     parser: &mut Parser<'de>,
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::Add)
+}
 
-    Ok(Expression::Binary {
-        operator: BinaryOperator::Multiply,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+pub fn multiplication<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    bp: BindingPower,
+) -> Result<Expression<'de>> {
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::Multiply)
 }
 
 pub fn subtraction<'de>(
@@ -38,13 +41,7 @@ pub fn subtraction<'de>(
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::Subtract,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::Subtract)
 }
 
 pub fn division<'de>(
@@ -52,13 +49,7 @@ pub fn division<'de>(
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::Divide,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::Divide)
 }
 
 pub fn modulo<'de>(
@@ -66,13 +57,7 @@ pub fn modulo<'de>(
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::Modulo,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::Modulo)
 }
 
 pub fn equal<'de>(
@@ -80,13 +65,7 @@ pub fn equal<'de>(
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::Equal,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::Equality)
 }
 
 pub fn not_equal<'de>(
@@ -94,13 +73,7 @@ pub fn not_equal<'de>(
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::NotEqual,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::Inequality)
 }
 
 pub fn less_than<'de>(
@@ -108,13 +81,7 @@ pub fn less_than<'de>(
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::LessThan,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::LessThan)
 }
 
 pub fn less_than_or_equal<'de>(
@@ -122,13 +89,7 @@ pub fn less_than_or_equal<'de>(
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::LessThanOrEqual,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::LessThanOrEqual)
 }
 
 pub fn greater_than<'de>(
@@ -136,13 +97,7 @@ pub fn greater_than<'de>(
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::GreaterThan,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::GreaterThan)
 }
 
 pub fn greater_than_or_equal<'de>(
@@ -150,13 +105,7 @@ pub fn greater_than_or_equal<'de>(
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::GreaterThanOrEqual,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::GreaterThanOrEqual)
 }
 
 pub fn and<'de>(
@@ -164,13 +113,7 @@ pub fn and<'de>(
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::And,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::And)
 }
 
 pub fn or<'de>(
@@ -178,11 +121,5 @@ pub fn or<'de>(
     lhs: Expression<'de>,
     bp: BindingPower,
 ) -> Result<Expression<'de>> {
-    let rhs = crate::parser::expression::parse(parser, bp)?;
-
-    Ok(Expression::Binary {
-        operator: BinaryOperator::Or,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    parse_binary_expression(parser, lhs, bp, BinaryOperator::Or)
 }

From b2def8483e04c480121c38c1ae1cc26a1c80d92b Mon Sep 17 00:00:00 2001
From: Lucas de Jong <lucas.dejong@cofano.nl>
Date: Tue, 29 Oct 2024 17:00:22 +0100
Subject: [PATCH 11/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs          |  6 +++++-
 src/parser/ast.rs    |  5 +++++
 src/parser/lookup.rs | 37 +++++++++++++++++++++++++++++++++++++
 3 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/src/main.rs b/src/main.rs
index 658d850..dedd8e3 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,7 +6,11 @@ pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "2 == 2 % 12;\n";
+    let input = "{1+1; 2 + 2;};\n";
+
+    let value = if 12 / 2 == 2 {
+        2;
+    };
 
     let mut parser = Parser::new(input);
     let symbol = match parser.parse() {
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index 85a32a5..d96385b 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -25,6 +25,10 @@ pub enum Expression<'de> {
         operand: Box<Expression<'de>>,
     },
     Group(Box<Expression<'de>>),
+    Block {
+        statements: Vec<Statement<'de>>,
+        return_value: Box<Expression<'de>>,
+    },
 }
 
 #[derive(Debug)]
@@ -33,6 +37,7 @@ pub enum Primitive<'de> {
     Decimal(f64),
     String(Cow<'de, str>),
     Boolean(bool),
+    Unit,
 }
 
 #[derive(Debug)]
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index d6146f4..717c49f 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -115,6 +115,7 @@ impl<'de> Default for Lookup<'de> {
         .add_expression_handler(TokenKind::If, if_)
         .add_expression_handler(TokenKind::Not, expression::unary::negate)
         .add_expression_handler(TokenKind::Minus, expression::unary::negative)
+        .add_expression_handler(TokenKind::CurlyOpen, block)
         .add_left_expression_handler(
             TokenKind::Plus,
             BindingPower::Additive,
@@ -201,3 +202,39 @@ fn group<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
 
     Ok(Expression::Group(Box::new(expression)))
 }
+
+fn block<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::CurlyOpen, "expected a left curly brace")?;
+
+    // A list of statements separated by semicolons. If the last statement is not ended with a semicolon, it is considered the return value.
+    let mut statements = Vec::new();
+    while parser.lexer.peek().map_or(false, |token| {
+        token
+            .as_ref()
+            .map_or(false, |token| token.kind != TokenKind::CurlyClose)
+    }) {
+        let statement = crate::parser::statement::parse(parser)?;
+        statements.push(statement);
+    }
+
+    let return_value = match statements.last() {
+        Some(Statement::Expression(_)) => match statements.pop() {
+            Some(Statement::Expression(expression)) => expression,
+            _ => unreachable!(),
+        },
+        _ => Expression::Primitive(Primitive::Unit),
+    };
+
+    let expression = Expression::Block {
+        statements,
+        return_value: Box::new(return_value),
+    };
+
+    parser
+        .lexer
+        .expect(TokenKind::CurlyClose, "expected a right curly brace")?;
+
+    Ok(Expression::Group(Box::new(expression)))
+}

From 14c222dbfe514001894e912b5b996dd23af068b1 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Tue, 29 Oct 2024 18:31:36 +0100
Subject: [PATCH 12/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs             |  6 +---
 src/parser/ast.rs       |  6 +++-
 src/parser/lookup.rs    | 71 +++++++++++++++++++++++++++++++++--------
 src/parser/mod.rs       |  2 +-
 src/parser/statement.rs | 13 +++++---
 5 files changed, 72 insertions(+), 26 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index dedd8e3..84821f7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,11 +6,7 @@ pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "{1+1; 2 + 2;};\n";
-
-    let value = if 12 / 2 == 2 {
-        2;
-    };
+    let input = "let value = if 12 % 2 == 0 true else false;\n";
 
     let mut parser = Parser::new(input);
     let symbol = match parser.parse() {
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index d96385b..a5c615d 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -8,7 +8,6 @@ pub enum Symbol<'de> {
 
 #[derive(Debug)]
 pub enum Statement<'de> {
-    Block(Vec<Statement<'de>>),
     Expression(Expression<'de>),
 }
 
@@ -29,6 +28,11 @@ pub enum Expression<'de> {
         statements: Vec<Statement<'de>>,
         return_value: Box<Expression<'de>>,
     },
+    If {
+        condition: Box<Expression<'de>>,
+        truthy: Box<Expression<'de>>,
+        falsy: Option<Box<Expression<'de>>>,
+    },
 }
 
 #[derive(Debug)]
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 717c49f..087aee2 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -184,11 +184,27 @@ impl<'de> Default for Lookup<'de> {
     }
 }
 
-fn if_<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
+fn if_<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
     parser.lexer.expect(TokenKind::If, "expected an if")?;
     let condition = expression::parse(parser, BindingPower::None)?;
+    let truthy = expression::parse(parser, BindingPower::None)?;
 
-    todo!()
+    let falsy = if parser.lexer.peek().map_or(false, |token| {
+        token
+            .as_ref()
+            .map_or(false, |token| token.kind == TokenKind::Else)
+    }) {
+        parser.lexer.next();
+        Some(expression::parse(parser, BindingPower::None)?)
+    } else {
+        None
+    };
+
+    Ok(Expression::If {
+        condition: Box::new(condition),
+        truthy: Box::new(truthy),
+        falsy: falsy.map(Box::new),
+    })
 }
 
 fn group<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
@@ -210,21 +226,48 @@ fn block<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
 
     // A list of statements separated by semicolons. If the last statement is not ended with a semicolon, it is considered the return value.
     let mut statements = Vec::new();
-    while parser.lexer.peek().map_or(false, |token| {
-        token
-            .as_ref()
-            .map_or(false, |token| token.kind != TokenKind::CurlyClose)
-    }) {
-        let statement = crate::parser::statement::parse(parser)?;
+    let mut last_is_return = true;
+
+    loop {
+        // Check if a closing curly brace is found.
+        if parser.lexer.peek().map_or(false, |token| {
+            token
+                .as_ref()
+                .map_or(false, |token| token.kind == TokenKind::CurlyClose)
+        }) {
+            break;
+        }
+
+        // Expect a semicolon after each statement except the last one.
+        if !statements.is_empty() {
+            parser
+                .lexer
+                .expect(TokenKind::Semicolon, "expected a semicolon")?;
+        }
+
+        if parser.lexer.peek().map_or(false, |token| {
+            token
+                .as_ref()
+                .map_or(false, |token| token.kind == TokenKind::CurlyClose)
+        }) {
+            last_is_return = false;
+            break;
+        }
+
+        let statement = crate::parser::statement::parse(parser, true)?;
         statements.push(statement);
     }
 
-    let return_value = match statements.last() {
-        Some(Statement::Expression(_)) => match statements.pop() {
-            Some(Statement::Expression(expression)) => expression,
-            _ => unreachable!(),
-        },
-        _ => Expression::Primitive(Primitive::Unit),
+    let return_value = if last_is_return {
+        match statements.last() {
+            Some(Statement::Expression(_)) => match statements.pop() {
+                Some(Statement::Expression(expression)) => expression,
+                _ => unreachable!(),
+            },
+            _ => Expression::Primitive(Primitive::Unit),
+        }
+    } else {
+        Expression::Primitive(Primitive::Unit)
     };
 
     let expression = Expression::Block {
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index d503412..33a132a 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -25,6 +25,6 @@ impl<'de> Parser<'de> {
     }
 
     pub fn parse(&mut self) -> Result<Symbol<'de>> {
-        Ok(Symbol::Statement(statement::parse(self)?))
+        Ok(Symbol::Statement(statement::parse(self, false)?))
     }
 }
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index 89da7a2..3ea05b7 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -3,12 +3,15 @@ use crate::lexer::TokenKind;
 use super::{ast::Statement, expression, lookup::BindingPower, Parser};
 use miette::{Context, Result};
 
-pub fn parse<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
+pub fn parse<'de>(parser: &mut Parser<'de>, optional_semicolon: bool) -> Result<Statement<'de>> {
     let expression = expression::parse(parser, BindingPower::None)?;
-    parser.lexer.expect(
-        TokenKind::Semicolon,
-        "expected a semicolon at the end of an expression",
-    )?;
+
+    if !optional_semicolon {
+        parser.lexer.expect(
+            TokenKind::Semicolon,
+            "expected a semicolon at the end of an expression",
+        )?;
+    }
 
     Ok(Statement::Expression(expression))
 }

From 71721d2ba578007cd1da28c8da52d8017b2590bd Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Tue, 29 Oct 2024 18:58:26 +0100
Subject: [PATCH 13/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs                        |  2 +-
 src/parser/expression/mod.rs       | 12 ++---------
 src/parser/expression/primitive.rs | 13 ++++++++++++
 src/parser/lookup.rs               | 15 +++++++------
 src/parser/statement.rs            | 34 ++++++++++++++++++++++++------
 5 files changed, 52 insertions(+), 24 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 84821f7..0917102 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,7 +6,7 @@ pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "let value = if 12 % 2 == 0 true else false;\n";
+    let input = "true if 12 % 2 == 0 else false;\n";
 
     let mut parser = Parser::new(input);
     let symbol = match parser.parse() {
diff --git a/src/parser/expression/mod.rs b/src/parser/expression/mod.rs
index f169758..c1d1b78 100644
--- a/src/parser/expression/mod.rs
+++ b/src/parser/expression/mod.rs
@@ -1,15 +1,7 @@
 use miette::Result;
 
-use crate::{
-    lexer::{TokenKind, TokenValue},
-    parser::lookup::BindingPower,
-};
-
-use super::{
-    ast::{BinaryOperator, Expression, Primitive},
-    lookup::Lookup,
-    Parser,
-};
+use super::{ast::Expression, Parser};
+use crate::parser::lookup::BindingPower;
 
 pub mod binary;
 pub mod primitive;
diff --git a/src/parser/expression/primitive.rs b/src/parser/expression/primitive.rs
index 70971df..e71156a 100644
--- a/src/parser/expression/primitive.rs
+++ b/src/parser/expression/primitive.rs
@@ -32,3 +32,16 @@ pub fn decimal<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
 
     Ok(Expression::Primitive(Primitive::Decimal(value)))
 }
+
+pub fn boolean<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
+    let token = parser
+        .lexer
+        .expect(TokenKind::Boolean, "expected a boolean")?;
+
+    let value = match token.value {
+        TokenValue::Boolean(v) => v,
+        _ => unreachable!(),
+    };
+
+    Ok(Expression::Primitive(Primitive::Boolean(value)))
+}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 087aee2..cc15390 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -111,8 +111,9 @@ impl<'de> Default for Lookup<'de> {
         }
         .add_expression_handler(TokenKind::Integer, expression::primitive::integer)
         .add_expression_handler(TokenKind::Decimal, expression::primitive::decimal)
+        .add_expression_handler(TokenKind::Boolean, expression::primitive::boolean)
         .add_expression_handler(TokenKind::ParenOpen, group)
-        .add_expression_handler(TokenKind::If, if_)
+        .add_left_expression_handler(TokenKind::If, BindingPower::None, if_)
         .add_expression_handler(TokenKind::Not, expression::unary::negate)
         .add_expression_handler(TokenKind::Minus, expression::unary::negative)
         .add_expression_handler(TokenKind::CurlyOpen, block)
@@ -184,10 +185,12 @@ impl<'de> Default for Lookup<'de> {
     }
 }
 
-fn if_<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
-    parser.lexer.expect(TokenKind::If, "expected an if")?;
-    let condition = expression::parse(parser, BindingPower::None)?;
-    let truthy = expression::parse(parser, BindingPower::None)?;
+fn if_<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    binding_power: BindingPower,
+) -> Result<Expression<'de>> {
+    let condition = expression::parse(parser, binding_power)?;
 
     let falsy = if parser.lexer.peek().map_or(false, |token| {
         token
@@ -202,7 +205,7 @@ fn if_<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
 
     Ok(Expression::If {
         condition: Box::new(condition),
-        truthy: Box::new(truthy),
+        truthy: Box::new(lhs),
         falsy: falsy.map(Box::new),
     })
 }
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index 3ea05b7..4a33695 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -6,12 +6,32 @@ use miette::{Context, Result};
 pub fn parse<'de>(parser: &mut Parser<'de>, optional_semicolon: bool) -> Result<Statement<'de>> {
     let expression = expression::parse(parser, BindingPower::None)?;
 
-    if !optional_semicolon {
-        parser.lexer.expect(
-            TokenKind::Semicolon,
-            "expected a semicolon at the end of an expression",
-        )?;
-    }
-
     Ok(Statement::Expression(expression))
+
+    // let token = match parser.lexer.peek().as_ref() {
+    //     Some(Ok(token)) => token,
+    //     Some(Err(err)) => return Err(miette::miette!(err.to_string())), // FIXME: better error handling
+    //     None => {
+    //         return Err(miette::miette! {
+    //             help = "expected a statement",
+    //             "expected a statement"
+    //         }
+    //         .with_source_code(parser.source.to_string()))
+    //     }
+    // };
+
+    // todo!()
+
+    // let statement_handler = parser.lookup.statement_lookup.get(&token.kind);
+
+    // // let expression = expression::parse(parser, BindingPower::None)?;
+
+    // // if !optional_semicolon {
+    // //     parser.lexer.expect(
+    // //         TokenKind::Semicolon,
+    // //         "expected a semicolon at the end of an expression",
+    // //     )?;
+    // // }
+
+    // Ok(Statement::Expression(expression))
 }

From a030b0dc1bba48003d007bfa6afe6d13509fcaf3 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Tue, 29 Oct 2024 21:44:29 +0100
Subject: [PATCH 14/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs                        |  2 +-
 src/parser/ast.rs                  |  2 ++
 src/parser/expression/primitive.rs | 39 ++++++++++++++++++++++++++++++
 src/parser/lookup.rs               |  3 +++
 4 files changed, 45 insertions(+), 1 deletion(-)

diff --git a/src/main.rs b/src/main.rs
index 0917102..9f9d917 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,7 +6,7 @@ pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "true if 12 % 2 == 0 else false;\n";
+    let input = "{(1); (3); (2);}";
 
     let mut parser = Parser::new(input);
     let symbol = match parser.parse() {
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index a5c615d..f19c4ef 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -40,6 +40,8 @@ pub enum Primitive<'de> {
     Integer(i64),
     Decimal(f64),
     String(Cow<'de, str>),
+    Identifier(Cow<'de, str>),
+    Character(char),
     Boolean(bool),
     Unit,
 }
diff --git a/src/parser/expression/primitive.rs b/src/parser/expression/primitive.rs
index e71156a..a234364 100644
--- a/src/parser/expression/primitive.rs
+++ b/src/parser/expression/primitive.rs
@@ -45,3 +45,42 @@ pub fn boolean<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
 
     Ok(Expression::Primitive(Primitive::Boolean(value)))
 }
+
+pub fn character<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
+    let token = parser
+        .lexer
+        .expect(TokenKind::Character, "expected a character")?;
+
+    let value = match token.value {
+        TokenValue::Character(v) => v,
+        _ => unreachable!(),
+    };
+
+    Ok(Expression::Primitive(Primitive::Character(value)))
+}
+
+pub fn string<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
+    let token = parser
+        .lexer
+        .expect(TokenKind::String, "expected a string")?;
+
+    let value = match token.value {
+        TokenValue::String(v) => v,
+        _ => unreachable!(),
+    };
+
+    Ok(Expression::Primitive(Primitive::String(value)))
+}
+
+pub fn identifier<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
+    let token = parser
+        .lexer
+        .expect(TokenKind::Identifier, "expected an identifier")?;
+
+    let value = match token.value {
+        TokenValue::Identifier(v) => v,
+        _ => unreachable!(),
+    };
+
+    Ok(Expression::Primitive(Primitive::Identifier(value)))
+}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index cc15390..a1e9485 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -112,6 +112,9 @@ impl<'de> Default for Lookup<'de> {
         .add_expression_handler(TokenKind::Integer, expression::primitive::integer)
         .add_expression_handler(TokenKind::Decimal, expression::primitive::decimal)
         .add_expression_handler(TokenKind::Boolean, expression::primitive::boolean)
+        .add_expression_handler(TokenKind::Character, expression::primitive::character)
+        .add_expression_handler(TokenKind::String, expression::primitive::string)
+        .add_expression_handler(TokenKind::Identifier, expression::primitive::identifier)
         .add_expression_handler(TokenKind::ParenOpen, group)
         .add_left_expression_handler(TokenKind::If, BindingPower::None, if_)
         .add_expression_handler(TokenKind::Not, expression::unary::negate)

From 4926fa7e5450e825203ab0b390aa2e781dd5daff Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Wed, 30 Oct 2024 00:28:14 +0100
Subject: [PATCH 15/43] =?UTF-8?q?=E2=9C=A8=20Add=20syntax=20highlighting?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: minor
---
 Cargo.lock                   | 306 ++++++++++++++++++++++++++++++++++-
 Cargo.toml                   |   3 +-
 src/lexer/mod.rs             |  52 +++---
 src/lexer/token.rs           |   1 +
 src/main.rs                  |  93 ++++++++++-
 src/parser/ast.rs            |   2 +
 src/parser/expression/mod.rs |  14 +-
 src/parser/lookup.rs         |   3 +-
 src/parser/mod.rs            |   8 +-
 src/parser/statement.rs      |  73 +++++----
 10 files changed, 486 insertions(+), 69 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ae6ea9c..05008ee 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -17,6 +17,12 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
+[[package]]
+name = "adler2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.3"
@@ -36,7 +42,7 @@ dependencies = [
  "cc",
  "cfg-if",
  "libc",
- "miniz_oxide",
+ "miniz_oxide 0.7.4",
  "object",
  "rustc-demangle",
 ]
@@ -50,6 +56,27 @@ dependencies = [
  "backtrace",
 ]
 
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
 [[package]]
 name = "bitflags"
 version = "2.6.0"
@@ -71,12 +98,36 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "crc32fast"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "deranged"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+dependencies = [
+ "powerfmt",
+]
+
 [[package]]
 name = "diff"
 version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
 
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
 [[package]]
 name = "errno"
 version = "0.3.9"
@@ -87,24 +138,68 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "flate2"
+version = "1.0.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1b589b4dc103969ad3cf85c950899926ec64300a1a46d76c03a6072957036f0"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide 0.8.0",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
 [[package]]
 name = "gimli"
 version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
 
+[[package]]
+name = "hashbrown"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e087f84d4f86bf4b218b927129862374b72199ae7d8657835f1e89000eea4fb"
+
+[[package]]
+name = "indexmap"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
 [[package]]
 name = "is_ci"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45"
 
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+
 [[package]]
 name = "libc"
 version = "0.2.161"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1"
 
+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.4.14"
@@ -131,6 +226,7 @@ dependencies = [
  "supports-color",
  "supports-hyperlinks",
  "supports-unicode",
+ "syntect",
  "terminal_size",
  "textwrap",
  "thiserror",
@@ -157,6 +253,21 @@ dependencies = [
  "adler",
 ]
 
+[[package]]
+name = "miniz_oxide"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1"
+dependencies = [
+ "adler2",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
 [[package]]
 name = "object"
 version = "0.36.5"
@@ -166,12 +277,65 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "once_cell"
+version = "1.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
+
+[[package]]
+name = "onig"
+version = "6.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c4b31c8722ad9171c6d77d3557db078cab2bd50afcc9d09c8b315c59df8ca4f"
+dependencies = [
+ "bitflags 1.3.2",
+ "libc",
+ "once_cell",
+ "onig_sys",
+]
+
+[[package]]
+name = "onig_sys"
+version = "69.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b829e3d7e9cc74c7e315ee8edb185bf4190da5acde74afd7fc59c35b1f086e7"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
+
 [[package]]
 name = "owo-colors"
 version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fb37767f6569cd834a413442455e0f066d0d522de8630436e2a1761d9726ba56"
 
+[[package]]
+name = "pkg-config"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
+
+[[package]]
+name = "plist"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42cf17e9a1800f5f396bc67d193dc9411b59012a5876445ef450d449881e1016"
+dependencies = [
+ "base64",
+ "indexmap",
+ "quick-xml",
+ "serde",
+ "time",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "pretty_assertions"
 version = "1.4.1"
@@ -191,6 +355,15 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "quick-xml"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d3a6e5838b60e0e8fa7a43f22ade549a37d61f8bdbe636d0d7816191de969c2"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.37"
@@ -241,13 +414,60 @@ version = "0.38.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
 dependencies = [
- "bitflags",
+ "bitflags 2.6.0",
  "errno",
  "libc",
  "linux-raw-sys",
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.132"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d726bfaff4b320266d395898905d0eba0345aae23b54aee3a737e260fd46db03"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
 [[package]]
 name = "shlex"
 version = "1.3.0"
@@ -265,6 +485,7 @@ name = "som"
 version = "0.1.0"
 dependencies = [
  "miette",
+ "owo-colors",
  "pretty_assertions",
  "regex",
 ]
@@ -301,6 +522,28 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "syntect"
+version = "5.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "874dcfa363995604333cf947ae9f751ca3af4522c60886774c4963943b4746b1"
+dependencies = [
+ "bincode",
+ "bitflags 1.3.2",
+ "flate2",
+ "fnv",
+ "once_cell",
+ "onig",
+ "plist",
+ "regex-syntax",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "thiserror",
+ "walkdir",
+ "yaml-rust",
+]
+
 [[package]]
 name = "terminal_size"
 version = "0.3.0"
@@ -342,6 +585,37 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "time"
+version = "0.3.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
+
+[[package]]
+name = "time-macros"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.13"
@@ -360,6 +634,25 @@ version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
 
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "winapi-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+dependencies = [
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -499,6 +792,15 @@ version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
 
+[[package]]
+name = "yaml-rust"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
+dependencies = [
+ "linked-hash-map",
+]
+
 [[package]]
 name = "yansi"
 version = "1.0.1"
diff --git a/Cargo.toml b/Cargo.toml
index 84362f8..793738d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,6 +7,7 @@ authors = ["Somfic"]
 description = "The 'som' programming language"
 
 [dependencies]
-miette = { version = "7.2.0", features = ["fancy"] }
+miette = { version = "7.2.0", features = ["fancy", "syntect-highlighter"] }
+owo-colors = "4.1.0"
 pretty_assertions = "1.4.1"
 regex = "1.10"
diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
index 4acaa68..5e54767 100644
--- a/src/lexer/mod.rs
+++ b/src/lexer/mod.rs
@@ -34,7 +34,7 @@ impl<'de> Lexer<'de> {
                 help = format!("expected {}, got {} instead", expected, token.kind),
                 "{unexpected}",
             }
-            .with_source_code(self.whole.to_string())),
+          ),
             Some(Err(e)) => Err(e),
             None => Err(miette::miette! {
                 labels = vec![
@@ -44,7 +44,7 @@ impl<'de> Lexer<'de> {
                 "unexpected end of input",
             }
             .wrap_err(unexpected.to_string())
-            .with_source_code(self.whole.to_string())),
+            ),
         }
     }
 
@@ -61,8 +61,7 @@ impl<'de> Lexer<'de> {
                 ],
                 help = format!("expected {token:?}"),
                 "{unexpected}",
-            }
-            .with_source_code(self.whole.to_string())),
+            }),
             Some(Err(e)) => Err(e),
             None => Err(miette::miette! {
                 labels = vec![
@@ -70,8 +69,7 @@ impl<'de> Lexer<'de> {
                 ],
                 help = "more source code was expected, but none was found",
                 "{unexpected}",
-            }
-            .with_source_code(self.whole.to_string())),
+            }),
         }
     }
 
@@ -149,8 +147,14 @@ impl<'de> Iterator for Lexer<'de> {
             '%' => Ok((TokenKind::Percent, TokenValue::None)),
             '=' => self.parse_compound_operator(TokenKind::Equal, TokenKind::Equality, '='),
             '!' => self.parse_compound_operator(TokenKind::Not, TokenKind::Inequality, '='),
-            '<' => self.parse_compound_operator(TokenKind::LessThan, TokenKind::LessThanOrEqual, '='),
-            '>' => self.parse_compound_operator(TokenKind::GreaterThan, TokenKind::GreaterThanOrEqual, '='),
+            '<' => {
+                self.parse_compound_operator(TokenKind::LessThan, TokenKind::LessThanOrEqual, '=')
+            }
+            '>' => self.parse_compound_operator(
+                TokenKind::GreaterThan,
+                TokenKind::GreaterThanOrEqual,
+                '=',
+            ),
             'a'..='z' | 'A'..='Z' | '_' => {
                 // Identifiers
                 let mut ident = String::new();
@@ -170,8 +174,12 @@ impl<'de> Iterator for Lexer<'de> {
                     "else" => Ok((TokenKind::Else, TokenValue::None)),
                     "fn" => Ok((TokenKind::Function, TokenValue::None)),
                     "true" => Ok((TokenKind::Boolean, TokenValue::Boolean(true))),
-                    "false" =>Ok((TokenKind::Boolean, TokenValue::Boolean(false))),
-                    ident => Ok((TokenKind::Identifier, TokenValue::Identifier(ident.to_string().into()))),
+                    "false" => Ok((TokenKind::Boolean, TokenValue::Boolean(false))),
+                    "let" => Ok((TokenKind::Let, TokenValue::None)),
+                    ident => Ok((
+                        TokenKind::Identifier,
+                        TokenValue::Identifier(ident.to_string().into()),
+                    )),
                 }
             }
             // Whole and decimal numbers
@@ -191,15 +199,14 @@ impl<'de> Iterator for Lexer<'de> {
                 if let Ok(num) = number.parse::<i64>() {
                     Ok((TokenKind::Integer, TokenValue::Integer(num)))
                 } else if let Ok(num) = number.parse::<f64>() {
-                     Ok((TokenKind::Decimal, TokenValue::Decimal(num)))
+                    Ok((TokenKind::Decimal, TokenValue::Decimal(num)))
                 } else {
                     Err(miette::miette! {
                         labels = vec![
                             LabeledSpan::at(self.byte_offset - number.len()..self.byte_offset, "this number")
                         ],
                         "invalid number"
-                    }
-                    .with_source_code(self.whole.to_string()))
+                    })
                 }
             }
             '"' => {
@@ -233,22 +240,18 @@ impl<'de> Iterator for Lexer<'de> {
                             LabeledSpan::at(self.byte_offset..self.byte_offset + c.len_utf8(), "this character")
                         ],
                         "expected closing single quote"
-                    }
-                    .with_source_code(self.whole.to_string()))
+                    })
                 }
             }
             ' ' | '\r' | '\t' | '\n' => {
                 return self.next();
             }
-            _ => {
-                Err(miette::miette! {
-                    labels = vec![
-                        LabeledSpan::at(self.byte_offset - c.len_utf8()..self.byte_offset, "this character")
-                    ],
-                    "unexpected character '{c}' in input"
-                }
-                .with_source_code(self.whole.to_string()))
-            }
+            _ => Err(miette::miette! {
+                labels = vec![
+                    LabeledSpan::at(self.byte_offset - c.len_utf8()..self.byte_offset, "this character")
+                ],
+                "unexpected character '{c}' in input"
+            }),
         };
 
         let byte_length = self
@@ -260,6 +263,7 @@ impl<'de> Iterator for Lexer<'de> {
             kind,
             value,
             span: SourceSpan::new(start_offset.into(), byte_length),
+            original: &self.whole[start_offset..self.byte_offset],
         }))
     }
 }
diff --git a/src/lexer/token.rs b/src/lexer/token.rs
index fb2043c..0140e66 100644
--- a/src/lexer/token.rs
+++ b/src/lexer/token.rs
@@ -4,6 +4,7 @@ use std::{borrow::Cow, fmt::Display, hash::Hash};
 pub struct Token<'de> {
     pub kind: TokenKind,
     pub value: TokenValue<'de>,
+    pub original: &'de str,
     pub span: miette::SourceSpan,
 }
 
diff --git a/src/main.rs b/src/main.rs
index 9f9d917..467748d 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,21 +1,106 @@
-use lexer::Lexer;
-use miette::LabeledSpan;
+use std::vec;
+
+use lexer::{Lexer, TokenKind};
+use miette::{highlighters::Highlighter, LabeledSpan};
+use owo_colors::{colors, styles, OwoColorize, Style, Styled};
 use parser::Parser;
 
 pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "{(1); (3); (2);}";
+    let input = "let value = a == { let b = 1 if true else 2 };";
+
+    miette::set_hook(Box::new(|_| {
+        Box::new(
+            miette::MietteHandlerOpts::new()
+                .terminal_links(true)
+                .unicode(true)
+                .context_lines(3)
+                .with_syntax_highlighting(SomHighlighter {})
+                .build(),
+        )
+    }))
+    .unwrap();
 
     let mut parser = Parser::new(input);
     let symbol = match parser.parse() {
         Ok(symbol) => symbol,
         Err(err) => {
-            println!("{:?}", err);
+            println!("{:?}", err.with_source_code(input.to_string()));
             return;
         }
     };
 
     println!("{:?}", symbol);
 }
+
+struct SomHighlighter {}
+struct SomHighlighterState {}
+
+impl miette::highlighters::Highlighter for SomHighlighter {
+    fn start_highlighter_state<'h>(
+        &'h self,
+        source: &dyn miette::SpanContents<'_>,
+    ) -> Box<dyn miette::highlighters::HighlighterState + 'h> {
+        Box::new(SomHighlighterState {})
+    }
+}
+
+impl miette::highlighters::HighlighterState for SomHighlighterState {
+    fn highlight_line<'s>(&mut self, line: &'s str) -> Vec<Styled<&'s str>> {
+        let mut sections: Vec<Styled<&'s str>> = vec![];
+
+        for word in line.split(' ') {
+            for token in Lexer::<'s>::new(word) {
+                let style: Style = match &token {
+                    Ok(token) => match &token.kind {
+                        // Comment / quote -> 92, 99, 112 + italic
+                        TokenKind::If | TokenKind::Else | TokenKind::Let => {
+                            Style::new().fg_rgb::<197, 120, 221>()
+                        }
+                        TokenKind::Identifier => Style::new().fg_rgb::<224, 108, 117>(),
+                        TokenKind::String => Style::new().fg_rgb::<152, 195, 121>().italic(),
+                        TokenKind::Integer | TokenKind::Decimal => {
+                            Style::new().fg_rgb::<209, 154, 102>()
+                        }
+                        TokenKind::Boolean => Style::new().fg_rgb::<86, 156, 214>(),
+                        TokenKind::CurlyOpen
+                        | TokenKind::CurlyClose
+                        | TokenKind::ParenOpen
+                        | TokenKind::ParenClose
+                        | TokenKind::SquareOpen
+                        | TokenKind::SquareClose
+                        | TokenKind::Equal
+                        | TokenKind::LessThan
+                        | TokenKind::GreaterThan
+                        | TokenKind::LessThanOrEqual
+                        | TokenKind::GreaterThanOrEqual
+                        | TokenKind::Equality
+                        | TokenKind::Inequality
+                        | TokenKind::Plus
+                        | TokenKind::Minus
+                        | TokenKind::Star
+                        | TokenKind::Slash
+                        | TokenKind::Percent
+                        | TokenKind::Not
+                        | TokenKind::And
+                        | TokenKind::Pipe
+                        | TokenKind::Caret
+                        | TokenKind::Or
+                        | TokenKind::Semicolon
+                        | TokenKind::Comma => Style::new().fg_rgb::<200, 200, 200>(),
+                        _ => Style::new().fg_rgb::<171, 178, 191>(),
+                    },
+                    Err(_) => return vec![Style::new().remove_all_effects().white().style(line)],
+                };
+
+                let token = token.unwrap();
+                sections.push(style.style(token.original));
+            }
+            sections.push(Style::new().remove_all_effects().style(" "));
+        }
+
+        sections
+    }
+}
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index f19c4ef..c7b85f4 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -8,7 +8,9 @@ pub enum Symbol<'de> {
 
 #[derive(Debug)]
 pub enum Statement<'de> {
+    Block(Vec<Statement<'de>>),
     Expression(Expression<'de>),
+    Assignment(Cow<'de, str>, Expression<'de>),
 }
 
 #[derive(Debug)]
diff --git a/src/parser/expression/mod.rs b/src/parser/expression/mod.rs
index c1d1b78..16f3e9f 100644
--- a/src/parser/expression/mod.rs
+++ b/src/parser/expression/mod.rs
@@ -18,19 +18,19 @@ pub fn parse<'de>(
             return Err(miette::miette! {
                 help = "expected an expression",
                 "expected an expression"
-            }
-            .with_source_code(parser.source.to_string()))
+            })
         }
     };
 
-    let handler = parser.lookup.expression_lookup.get(&token.kind).ok_or(
-        miette::miette! {
+    let handler = parser
+        .lookup
+        .expression_lookup
+        .get(&token.kind)
+        .ok_or(miette::miette! {
             labels = vec![token.label("expected an expression")],
             help = format!("{} is not an expression", token.kind),
             "expected an expression, found {}", token.kind
-        }
-        .with_source_code(parser.source.to_string()),
-    )?;
+        })?;
     let mut lhs = handler(parser)?;
 
     let mut next_token = parser.lexer.peek();
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index a1e9485..b7a196a 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;
 
 use super::{
     ast::{BinaryOperator, Expression, Primitive, Statement},
-    expression, Parser,
+    expression, statement, Parser,
 };
 
 #[derive(Debug, Clone, PartialEq, PartialOrd)]
@@ -185,6 +185,7 @@ impl<'de> Default for Lookup<'de> {
             BindingPower::Relational,
             expression::binary::or,
         )
+        .add_statement_handler(TokenKind::Let, statement::let_)
     }
 }
 
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index 33a132a..fd93bb8 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -25,6 +25,12 @@ impl<'de> Parser<'de> {
     }
 
     pub fn parse(&mut self) -> Result<Symbol<'de>> {
-        Ok(Symbol::Statement(statement::parse(self, false)?))
+        let mut statements = vec![];
+
+        while self.lexer.peek().is_some() {
+            statements.push(statement::parse(self, false).wrap_err("while parsing main block")?);
+        }
+
+        Ok(Symbol::Statement(Statement::Block(statements)))
     }
 }
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index 4a33695..86d64b4 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -1,37 +1,52 @@
-use crate::lexer::TokenKind;
+use crate::lexer::{TokenKind, TokenValue};
 
 use super::{ast::Statement, expression, lookup::BindingPower, Parser};
 use miette::{Context, Result};
 
 pub fn parse<'de>(parser: &mut Parser<'de>, optional_semicolon: bool) -> Result<Statement<'de>> {
-    let expression = expression::parse(parser, BindingPower::None)?;
-
-    Ok(Statement::Expression(expression))
-
-    // let token = match parser.lexer.peek().as_ref() {
-    //     Some(Ok(token)) => token,
-    //     Some(Err(err)) => return Err(miette::miette!(err.to_string())), // FIXME: better error handling
-    //     None => {
-    //         return Err(miette::miette! {
-    //             help = "expected a statement",
-    //             "expected a statement"
-    //         }
-    //         .with_source_code(parser.source.to_string()))
-    //     }
-    // };
-
-    // todo!()
-
-    // let statement_handler = parser.lookup.statement_lookup.get(&token.kind);
-
-    // // let expression = expression::parse(parser, BindingPower::None)?;
+    let token = match parser.lexer.peek().as_ref() {
+        Some(Ok(token)) => token,
+        Some(Err(err)) => return Err(miette::miette!(err.to_string())), // FIXME: better error handling
+        None => {
+            return Err(miette::miette! {
+                help = "expected a statement",
+                "expected a statement"
+            })
+        }
+    };
+
+    let statement_handler = parser.lookup.statement_lookup.get(&token.kind);
+
+    let statement = match statement_handler {
+        Some(handler) => handler(parser)?,
+        None => Statement::Expression(expression::parse(parser, BindingPower::None)?),
+    };
+
+    if !optional_semicolon {
+        parser.lexer.expect(
+            TokenKind::Semicolon,
+            "expected a semicolon at the end of an expression",
+        )?;
+    };
+
+    Ok(statement)
+}
 
-    // // if !optional_semicolon {
-    // //     parser.lexer.expect(
-    // //         TokenKind::Semicolon,
-    // //         "expected a semicolon at the end of an expression",
-    // //     )?;
-    // // }
+pub fn let_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::Let, "expected a let keyword")?;
+    let identifier = parser
+        .lexer
+        .expect(TokenKind::Identifier, "expected an identifier")?;
+    let identifier = match identifier.value {
+        TokenValue::Identifier(identifier) => identifier,
+        _ => unreachable!(),
+    };
+    parser
+        .lexer
+        .expect(TokenKind::Equal, "expected an equal sign")?;
+    let expression = expression::parse(parser, BindingPower::None)?;
 
-    // Ok(Statement::Expression(expression))
+    Ok(Statement::Assignment(identifier, expression))
 }

From 05a05c0bd404a5ff0dfac0455e0dab977767fe86 Mon Sep 17 00:00:00 2001
From: Lucas de Jong <lucas.dejong@cofano.nl>
Date: Wed, 30 Oct 2024 16:17:20 +0100
Subject: [PATCH 16/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/lexer/mod.rs        |   3 +
 src/lexer/token.rs      |   7 +-
 src/main.rs             |  40 ++++---
 src/parser/ast.rs       |  17 +++
 src/parser/lookup.rs    |   4 +
 src/parser/mod.rs       |   2 +-
 src/parser/statement.rs | 260 ++++++++++++++++++++++++++++++++++++++--
 7 files changed, 308 insertions(+), 25 deletions(-)

diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
index 5e54767..464f5c1 100644
--- a/src/lexer/mod.rs
+++ b/src/lexer/mod.rs
@@ -176,6 +176,9 @@ impl<'de> Iterator for Lexer<'de> {
                     "true" => Ok((TokenKind::Boolean, TokenValue::Boolean(true))),
                     "false" => Ok((TokenKind::Boolean, TokenValue::Boolean(false))),
                     "let" => Ok((TokenKind::Let, TokenValue::None)),
+                    "struct" => Ok((TokenKind::Struct, TokenValue::None)),
+                    "enum" => Ok((TokenKind::Enum, TokenValue::None)),
+                    "trait" => Ok((TokenKind::Trait, TokenValue::None)),
                     ident => Ok((
                         TokenKind::Identifier,
                         TokenValue::Identifier(ident.to_string().into()),
diff --git a/src/lexer/token.rs b/src/lexer/token.rs
index 0140e66..138ad70 100644
--- a/src/lexer/token.rs
+++ b/src/lexer/token.rs
@@ -163,6 +163,8 @@ pub enum TokenKind {
     Struct,
     /// A enum keyword; `enum`.
     Enum,
+    /// A trait keyword; `trait`.
+    Trait,
 }
 
 impl Display for TokenKind {
@@ -216,8 +218,9 @@ impl Display for TokenKind {
             TokenKind::Question => write!(f, "`?`"),
             TokenKind::Pipe => write!(f, "`|`"),
             TokenKind::Caret => write!(f, "`^`"),
-            TokenKind::And => todo!("`&&`"),
-            TokenKind::Or => todo!("`||`"),
+            TokenKind::And => write!(f, "`&&`"),
+            TokenKind::Or => write!(f, "`||`"),
+            TokenKind::Trait => write!(f, "`trait`"),
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 467748d..08796de 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -9,7 +9,23 @@ pub mod lexer;
 pub mod parser;
 
 fn main() {
-    let input = "let value = a == { let b = 1 if true else 2 };";
+    let input = "
+    let x = {1};
+    let a = \"hello\";
+    let b = 123;
+    let b = b if b <= 100 else 100;
+
+    struct Human: name, age;
+    enum Color: red, green, blue, orange;
+
+    fn add(a, b) { a + b }
+    fn sub(a, b) { a - b }
+    fn mul(a, b) { a * b }
+    fn div(a, b) { a / b }
+
+    trait Add: 
+        fn add(a, b);
+    ";
 
     miette::set_hook(Box::new(|_| {
         Box::new(
@@ -56,32 +72,26 @@ impl miette::highlighters::HighlighterState for SomHighlighterState {
                 let style: Style = match &token {
                     Ok(token) => match &token.kind {
                         // Comment / quote -> 92, 99, 112 + italic
-                        TokenKind::If | TokenKind::Else | TokenKind::Let => {
-                            Style::new().fg_rgb::<197, 120, 221>()
-                        }
+                        TokenKind::If
+                        | TokenKind::Else
+                        | TokenKind::Let
+                        | TokenKind::Struct
+                        | TokenKind::Enum
+                        | TokenKind::Function | TokenKind::Trait => Style::new().fg_rgb::<197, 120, 221>(),
                         TokenKind::Identifier => Style::new().fg_rgb::<224, 108, 117>(),
                         TokenKind::String => Style::new().fg_rgb::<152, 195, 121>().italic(),
                         TokenKind::Integer | TokenKind::Decimal => {
                             Style::new().fg_rgb::<209, 154, 102>()
                         }
                         TokenKind::Boolean => Style::new().fg_rgb::<86, 156, 214>(),
-                        TokenKind::CurlyOpen
-                        | TokenKind::CurlyClose
-                        | TokenKind::ParenOpen
-                        | TokenKind::ParenClose
-                        | TokenKind::SquareOpen
-                        | TokenKind::SquareClose
-                        | TokenKind::Equal
+
+                        TokenKind::Equal
                         | TokenKind::LessThan
                         | TokenKind::GreaterThan
                         | TokenKind::LessThanOrEqual
                         | TokenKind::GreaterThanOrEqual
                         | TokenKind::Equality
                         | TokenKind::Inequality
-                        | TokenKind::Plus
-                        | TokenKind::Minus
-                        | TokenKind::Star
-                        | TokenKind::Slash
                         | TokenKind::Percent
                         | TokenKind::Not
                         | TokenKind::And
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index c7b85f4..13cd0ac 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -11,6 +11,23 @@ pub enum Statement<'de> {
     Block(Vec<Statement<'de>>),
     Expression(Expression<'de>),
     Assignment(Cow<'de, str>, Expression<'de>),
+    Struct {
+        name: Cow<'de, str>,
+        fields: Vec<Cow<'de, str>>,
+    },
+    Enum {
+        name: Cow<'de, str>,
+        variants: Vec<Cow<'de, str>>,
+    },
+    Function {
+        name: Cow<'de, str>,
+        parameters: Vec<Cow<'de, str>>,
+        body: Expression<'de>,
+    },
+    Trait {
+        name: Cow<'de, str>,
+        functions: Vec<(Cow<'de, str>, Vec<Cow<'de, str>>)>,
+    },
 }
 
 #[derive(Debug)]
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index b7a196a..608696f 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -186,6 +186,10 @@ impl<'de> Default for Lookup<'de> {
             expression::binary::or,
         )
         .add_statement_handler(TokenKind::Let, statement::let_)
+        .add_statement_handler(TokenKind::Struct, statement::struct_)
+        .add_statement_handler(TokenKind::Enum, statement::enum_)
+        .add_statement_handler(TokenKind::Function, statement::function_)
+        .add_statement_handler(TokenKind::Trait, statement::trait_)
     }
 }
 
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index fd93bb8..f3bff49 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -28,7 +28,7 @@ impl<'de> Parser<'de> {
         let mut statements = vec![];
 
         while self.lexer.peek().is_some() {
-            statements.push(statement::parse(self, false).wrap_err("while parsing main block")?);
+            statements.push(statement::parse(self, false)?);
         }
 
         Ok(Symbol::Statement(Statement::Block(statements)))
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index 86d64b4..b362e1a 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -17,16 +17,26 @@ pub fn parse<'de>(parser: &mut Parser<'de>, optional_semicolon: bool) -> Result<
 
     let statement_handler = parser.lookup.statement_lookup.get(&token.kind);
 
+    let token_kind = &token.clone();
+
     let statement = match statement_handler {
         Some(handler) => handler(parser)?,
-        None => Statement::Expression(expression::parse(parser, BindingPower::None)?),
-    };
+        None => {
+            let expression = expression::parse(parser, BindingPower::None)
+                .wrap_err("while parsing a statement")?;
+
+            if !optional_semicolon {
+                parser
+                    .lexer
+                    .expect(
+                        TokenKind::Semicolon,
+                        "expected a semicolon at the end of an expression",
+                    )
+                    .wrap_err(format!("while parsing for {}", token_kind))?;
+            }
 
-    if !optional_semicolon {
-        parser.lexer.expect(
-            TokenKind::Semicolon,
-            "expected a semicolon at the end of an expression",
-        )?;
+            Statement::Expression(expression)
+        }
     };
 
     Ok(statement)
@@ -48,5 +58,241 @@ pub fn let_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .expect(TokenKind::Equal, "expected an equal sign")?;
     let expression = expression::parse(parser, BindingPower::None)?;
 
+    parser
+        .lexer
+        .expect(TokenKind::Semicolon, "expected a semicolon")?;
+
     Ok(Statement::Assignment(identifier, expression))
 }
+
+pub fn struct_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::Struct, "expected a struct keyword")?;
+
+    let identifier = parser
+        .lexer
+        .expect(TokenKind::Identifier, "expected an identifier")?;
+
+    let identifier = match identifier.value {
+        TokenValue::Identifier(identifier) => identifier,
+        _ => unreachable!(),
+    };
+
+    parser.lexer.expect(TokenKind::Colon, "expected a colon")?;
+
+    let mut fields = vec![];
+
+    while parser.lexer.peek().map_or(false, |token| {
+        token
+            .as_ref()
+            .map_or(false, |token| token.kind != TokenKind::Semicolon)
+    }) {
+        if !fields.is_empty() {
+            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+        }
+
+        let field = parser
+            .lexer
+            .expect(TokenKind::Identifier, "expected an identifier")?;
+
+        let field = match field.value {
+            TokenValue::Identifier(field) => field,
+            _ => unreachable!(),
+        };
+
+        fields.push(field);
+    }
+
+    parser
+        .lexer
+        .expect(TokenKind::Semicolon, "expected a semicolon")?;
+
+    Ok(Statement::Struct {
+        name: identifier,
+        fields,
+    })
+}
+
+pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::Enum, "expected an enum keyword")?;
+
+    let identifier = parser
+        .lexer
+        .expect(TokenKind::Identifier, "expected an identifier")?;
+
+    let identifier = match identifier.value {
+        TokenValue::Identifier(identifier) => identifier,
+        _ => unreachable!(),
+    };
+
+    parser.lexer.expect(TokenKind::Colon, "expected a colon")?;
+
+    let mut variants = vec![];
+
+    while parser.lexer.peek().map_or(false, |token| {
+        token
+            .as_ref()
+            .map_or(false, |token| token.kind != TokenKind::Semicolon)
+    }) {
+        if !variants.is_empty() {
+            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+        }
+
+        let variant = parser
+            .lexer
+            .expect(TokenKind::Identifier, "expected an identifier")?;
+
+        let variant = match variant.value {
+            TokenValue::Identifier(variant) => variant,
+            _ => unreachable!(),
+        };
+
+        variants.push(variant);
+    }
+
+    parser
+        .lexer
+        .expect(TokenKind::Semicolon, "expected a semicolon")?;
+
+    Ok(Statement::Enum {
+        name: identifier,
+        variants,
+    })
+}
+
+pub fn function_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::Function, "expected a fn keyword")?;
+
+    let identifier = parser
+        .lexer
+        .expect(TokenKind::Identifier, "expected an identifier")?;
+
+    let identifier = match identifier.value {
+        TokenValue::Identifier(identifier) => identifier,
+        _ => unreachable!(),
+    };
+
+    parser
+        .lexer
+        .expect(TokenKind::ParenOpen, "expected an open parenthesis")?;
+
+    let mut parameters = vec![];
+
+    while parser.lexer.peek().map_or(false, |token| {
+        token
+            .as_ref()
+            .map_or(false, |token| token.kind != TokenKind::ParenClose)
+    }) {
+        if !parameters.is_empty() {
+            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+        }
+
+        let parameter = parser
+            .lexer
+            .expect(TokenKind::Identifier, "expected an identifier")?;
+
+        let parameter = match parameter.value {
+            TokenValue::Identifier(parameter) => parameter,
+            _ => unreachable!(),
+        };
+
+        parameters.push(parameter);
+    }
+
+    parser
+        .lexer
+        .expect(TokenKind::ParenClose, "expected a close parenthesis")?;
+
+    let body = expression::parse(parser, BindingPower::None)?;
+
+    Ok(Statement::Function {
+        name: identifier,
+        parameters,
+        body,
+    })
+}
+
+pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::Trait, "expected a trait keyword")?;
+
+    let identifier = parser
+        .lexer
+        .expect(TokenKind::Identifier, "expected an identifier")?;
+
+    let identifier = match identifier.value {
+        TokenValue::Identifier(identifier) => identifier,
+        _ => unreachable!(),
+    };
+
+    parser.lexer.expect(TokenKind::Colon, "expected a colon")?;
+
+    let mut functions = vec![];
+
+    while parser.lexer.peek().map_or(false, |token| {
+        token
+            .as_ref()
+            .map_or(false, |token| token.kind != TokenKind::Semicolon)
+    }) {
+        if !functions.is_empty() {
+            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+        }
+
+        parser
+            .lexer
+            .expect(TokenKind::Function, "expected a fn keyword")?;
+
+        let function = parser
+            .lexer
+            .expect(TokenKind::Identifier, "expected an identifier")?;
+
+        let function = match function.value {
+            TokenValue::Identifier(function) => function,
+            _ => unreachable!(),
+        };
+
+        parser
+            .lexer
+            .expect(TokenKind::ParenOpen, "expected an open parenthesis")?;
+
+        let mut parameters = vec![];
+
+        while parser.lexer.peek().map_or(false, |token| {
+            token
+                .as_ref()
+                .map_or(false, |token| token.kind != TokenKind::ParenClose)
+        }) {
+            if !parameters.is_empty() {
+                parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+            }
+
+            let parameter = parser
+                .lexer
+                .expect(TokenKind::Identifier, "expected an identifier")?;
+
+            let parameter = match parameter.value {
+                TokenValue::Identifier(parameter) => parameter,
+                _ => unreachable!(),
+            };
+
+            parameters.push(parameter);
+        }
+
+        functions.push((function, parameters));
+    }
+
+    parser
+        .lexer
+        .expect(TokenKind::Semicolon, "expected a semicolon")?;
+
+    Ok(Statement::Trait {
+        name: identifier,
+        functions,
+    })
+}

From 811c453b1293af686705ef77b98be7a68353fa3e Mon Sep 17 00:00:00 2001
From: Lucas de Jong <lucas.dejong@cofano.nl>
Date: Wed, 30 Oct 2024 16:22:49 +0100
Subject: [PATCH 17/43] =?UTF-8?q?=F0=9F=8E=A8=20Format?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main.rs b/src/main.rs
index 08796de..c05e2cd 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -77,7 +77,8 @@ impl miette::highlighters::HighlighterState for SomHighlighterState {
                         | TokenKind::Let
                         | TokenKind::Struct
                         | TokenKind::Enum
-                        | TokenKind::Function | TokenKind::Trait => Style::new().fg_rgb::<197, 120, 221>(),
+                        | TokenKind::Function
+                        | TokenKind::Trait => Style::new().fg_rgb::<197, 120, 221>(),
                         TokenKind::Identifier => Style::new().fg_rgb::<224, 108, 117>(),
                         TokenKind::String => Style::new().fg_rgb::<152, 195, 121>().italic(),
                         TokenKind::Integer | TokenKind::Decimal => {

From 675a03489b8e0f6503ab27744852ba982aa5cc6a Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Wed, 30 Oct 2024 19:19:46 +0100
Subject: [PATCH 18/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs                  | 23 ++++++-----------
 src/parser/ast.rs            |  4 +++
 src/parser/expression/mod.rs | 34 ++++++++++++++++++++++++-
 src/parser/lookup.rs         |  1 +
 src/parser/statement.rs      | 48 +++++++++++++++++++++++-------------
 5 files changed, 77 insertions(+), 33 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index c05e2cd..e562d5f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,22 +10,15 @@ pub mod parser;
 
 fn main() {
     let input = "
-    let x = {1};
-    let a = \"hello\";
-    let b = 123;
-    let b = b if b <= 100 else 100;
-
-    struct Human: name, age;
-    enum Color: red, green, blue, orange;
-
-    fn add(a, b) { a + b }
-    fn sub(a, b) { a - b }
-    fn mul(a, b) { a * b }
-    fn div(a, b) { a / b }
+    fn main() {
+        fib(9999);
+    }
 
-    trait Add: 
-        fn add(a, b);
-    ";
+    fn fib(n ~ number) ~ number {
+        return if n < 2;
+        fib(n - 1) + fib(n - 2)
+    }
+        ";
 
     miette::set_hook(Box::new(|_| {
         Box::new(
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index 13cd0ac..8cb62c1 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -52,6 +52,10 @@ pub enum Expression<'de> {
         truthy: Box<Expression<'de>>,
         falsy: Option<Box<Expression<'de>>>,
     },
+    Call {
+        callee: Box<Expression<'de>>,
+        arguments: Vec<Expression<'de>>,
+    },
 }
 
 #[derive(Debug)]
diff --git a/src/parser/expression/mod.rs b/src/parser/expression/mod.rs
index 16f3e9f..f0b6f80 100644
--- a/src/parser/expression/mod.rs
+++ b/src/parser/expression/mod.rs
@@ -1,7 +1,7 @@
 use miette::Result;
 
 use super::{ast::Expression, Parser};
-use crate::parser::lookup::BindingPower;
+use crate::{lexer::TokenKind, parser::lookup::BindingPower};
 
 pub mod binary;
 pub mod primitive;
@@ -67,3 +67,35 @@ pub fn parse<'de>(
 
     Ok(lhs)
 }
+
+pub fn call<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    binding_power: BindingPower,
+) -> Result<Expression<'de>> {
+    let mut arguments = Vec::new();
+
+    while parser.lexer.peek().map_or(false, |token| {
+        token
+            .as_ref()
+            .map_or(false, |token| token.kind != TokenKind::ParenClose)
+    }) {
+        if !arguments.is_empty() {
+            parser
+                .lexer
+                .expect(TokenKind::Comma, "expected a comma between arguments")?;
+        }
+
+        let argument = parse(parser, BindingPower::None)?;
+        arguments.push(argument);
+    }
+
+    parser
+        .lexer
+        .expect(TokenKind::ParenClose, "expected a closing parenthesis")?;
+
+    Ok(Expression::Call {
+        callee: Box::new(lhs),
+        arguments,
+    })
+}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 608696f..d741218 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -117,6 +117,7 @@ impl<'de> Default for Lookup<'de> {
         .add_expression_handler(TokenKind::Identifier, expression::primitive::identifier)
         .add_expression_handler(TokenKind::ParenOpen, group)
         .add_left_expression_handler(TokenKind::If, BindingPower::None, if_)
+        .add_left_expression_handler(TokenKind::ParenOpen, BindingPower::None, expression::call)
         .add_expression_handler(TokenKind::Not, expression::unary::negate)
         .add_expression_handler(TokenKind::Minus, expression::unary::negative)
         .add_expression_handler(TokenKind::CurlyOpen, block)
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index b362e1a..62212d0 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -48,7 +48,7 @@ pub fn let_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .expect(TokenKind::Let, "expected a let keyword")?;
     let identifier = parser
         .lexer
-        .expect(TokenKind::Identifier, "expected an identifier")?;
+        .expect(TokenKind::Identifier, "expected a variable name")?;
     let identifier = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
         _ => unreachable!(),
@@ -72,7 +72,7 @@ pub fn struct_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
 
     let identifier = parser
         .lexer
-        .expect(TokenKind::Identifier, "expected an identifier")?;
+        .expect(TokenKind::Identifier, "expected a struct name")?;
 
     let identifier = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
@@ -89,12 +89,14 @@ pub fn struct_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             .map_or(false, |token| token.kind != TokenKind::Semicolon)
     }) {
         if !fields.is_empty() {
-            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+            parser
+                .lexer
+                .expect(TokenKind::Comma, "expected a comma between fields")?;
         }
 
         let field = parser
             .lexer
-            .expect(TokenKind::Identifier, "expected an identifier")?;
+            .expect(TokenKind::Identifier, "expected a field name")?;
 
         let field = match field.value {
             TokenValue::Identifier(field) => field,
@@ -121,7 +123,7 @@ pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
 
     let identifier = parser
         .lexer
-        .expect(TokenKind::Identifier, "expected an identifier")?;
+        .expect(TokenKind::Identifier, "expected an enum name")?;
 
     let identifier = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
@@ -138,12 +140,14 @@ pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             .map_or(false, |token| token.kind != TokenKind::Semicolon)
     }) {
         if !variants.is_empty() {
-            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+            parser
+                .lexer
+                .expect(TokenKind::Comma, "expected a comma between enum members")?;
         }
 
         let variant = parser
             .lexer
-            .expect(TokenKind::Identifier, "expected an identifier")?;
+            .expect(TokenKind::Identifier, "expected an enum member name")?;
 
         let variant = match variant.value {
             TokenValue::Identifier(variant) => variant,
@@ -166,11 +170,11 @@ pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
 pub fn function_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
     parser
         .lexer
-        .expect(TokenKind::Function, "expected a fn keyword")?;
+        .expect(TokenKind::Function, "expected a function keyword")?;
 
     let identifier = parser
         .lexer
-        .expect(TokenKind::Identifier, "expected an identifier")?;
+        .expect(TokenKind::Identifier, "expected function name")?;
 
     let identifier = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
@@ -189,12 +193,14 @@ pub fn function_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             .map_or(false, |token| token.kind != TokenKind::ParenClose)
     }) {
         if !parameters.is_empty() {
-            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+            parser
+                .lexer
+                .expect(TokenKind::Comma, "expected a comma between parameters")?;
         }
 
         let parameter = parser
             .lexer
-            .expect(TokenKind::Identifier, "expected an identifier")?;
+            .expect(TokenKind::Identifier, "expected a parameter name")?;
 
         let parameter = match parameter.value {
             TokenValue::Identifier(parameter) => parameter,
@@ -224,7 +230,7 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
 
     let identifier = parser
         .lexer
-        .expect(TokenKind::Identifier, "expected an identifier")?;
+        .expect(TokenKind::Identifier, "expected a trait name")?;
 
     let identifier = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
@@ -241,16 +247,18 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             .map_or(false, |token| token.kind != TokenKind::Semicolon)
     }) {
         if !functions.is_empty() {
-            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+            parser
+                .lexer
+                .expect(TokenKind::Comma, "expected a comma between functions")?;
         }
 
         parser
             .lexer
-            .expect(TokenKind::Function, "expected a fn keyword")?;
+            .expect(TokenKind::Function, "expected a function keyword")?;
 
         let function = parser
             .lexer
-            .expect(TokenKind::Identifier, "expected an identifier")?;
+            .expect(TokenKind::Identifier, "expected a function name")?;
 
         let function = match function.value {
             TokenValue::Identifier(function) => function,
@@ -269,12 +277,14 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
                 .map_or(false, |token| token.kind != TokenKind::ParenClose)
         }) {
             if !parameters.is_empty() {
-                parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+                parser
+                    .lexer
+                    .expect(TokenKind::Comma, "expected a comma in between arguments")?;
             }
 
             let parameter = parser
                 .lexer
-                .expect(TokenKind::Identifier, "expected an identifier")?;
+                .expect(TokenKind::Identifier, "expected an argument name")?;
 
             let parameter = match parameter.value {
                 TokenValue::Identifier(parameter) => parameter,
@@ -284,6 +294,10 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             parameters.push(parameter);
         }
 
+        parser
+            .lexer
+            .expect(TokenKind::ParenClose, "expected a close parenthesis")?;
+
         functions.push((function, parameters));
     }
 

From fbc4569f96e9e2f4ed91a6480dc6fead924ed179 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Wed, 30 Oct 2024 19:26:19 +0100
Subject: [PATCH 19/43] =?UTF-8?q?=F0=9F=8E=A8=20Fix=20cargo=20clippy=20war?=
 =?UTF-8?q?nings?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/lexer/mod.rs             | 2 +-
 src/main.rs                  | 8 +++-----
 src/parser/expression/mod.rs | 2 +-
 src/parser/lookup.rs         | 9 ++++-----
 src/parser/mod.rs            | 9 +++------
 5 files changed, 12 insertions(+), 18 deletions(-)

diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
index 464f5c1..1d1341e 100644
--- a/src/lexer/mod.rs
+++ b/src/lexer/mod.rs
@@ -190,7 +190,7 @@ impl<'de> Iterator for Lexer<'de> {
                 let mut number = String::new();
                 number.push(c);
                 while let Some(c) = self.remainder.chars().next() {
-                    if c.is_digit(10) || c == '.' {
+                    if c.is_ascii_digit() || c == '.' {
                         number.push(c);
                         self.remainder = &self.remainder[c.len_utf8()..];
                         self.byte_offset += c.len_utf8();
diff --git a/src/main.rs b/src/main.rs
index e562d5f..16df000 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,9 +1,7 @@
-use std::vec;
-
 use lexer::{Lexer, TokenKind};
-use miette::{highlighters::Highlighter, LabeledSpan};
-use owo_colors::{colors, styles, OwoColorize, Style, Styled};
+use owo_colors::{Style, Styled};
 use parser::Parser;
+use std::vec;
 
 pub mod lexer;
 pub mod parser;
@@ -50,7 +48,7 @@ struct SomHighlighterState {}
 impl miette::highlighters::Highlighter for SomHighlighter {
     fn start_highlighter_state<'h>(
         &'h self,
-        source: &dyn miette::SpanContents<'_>,
+        _source: &dyn miette::SpanContents<'_>,
     ) -> Box<dyn miette::highlighters::HighlighterState + 'h> {
         Box::new(SomHighlighterState {})
     }
diff --git a/src/parser/expression/mod.rs b/src/parser/expression/mod.rs
index f0b6f80..8850455 100644
--- a/src/parser/expression/mod.rs
+++ b/src/parser/expression/mod.rs
@@ -86,7 +86,7 @@ pub fn call<'de>(
                 .expect(TokenKind::Comma, "expected a comma between arguments")?;
         }
 
-        let argument = parse(parser, BindingPower::None)?;
+        let argument = parse(parser, binding_power.clone())?;
         arguments.push(argument);
     }
 
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index d741218..e945550 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -1,11 +1,10 @@
-use crate::lexer::{TokenKind, TokenValue};
-use miette::Result;
-use std::collections::HashMap;
-
 use super::{
-    ast::{BinaryOperator, Expression, Primitive, Statement},
+    ast::{Expression, Primitive, Statement},
     expression, statement, Parser,
 };
+use crate::lexer::TokenKind;
+use miette::Result;
+use std::collections::HashMap;
 
 #[derive(Debug, Clone, PartialEq, PartialOrd)]
 pub enum BindingPower {
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index f3bff49..d683647 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -1,8 +1,7 @@
-use crate::lexer::{Lexer, Token, TokenKind};
+use crate::lexer::Lexer;
 use ast::{Statement, Symbol};
-use lookup::{BindingPower, Lookup};
-use miette::{Context, Error, Result};
-use std::{borrow::Cow, collections::HashMap};
+use lookup::Lookup;
+use miette::Result;
 
 pub mod ast;
 pub mod expression;
@@ -10,7 +9,6 @@ pub mod lookup;
 pub mod statement;
 
 pub struct Parser<'de> {
-    source: &'de str,
     lexer: Lexer<'de>,
     lookup: Lookup<'de>,
 }
@@ -18,7 +16,6 @@ pub struct Parser<'de> {
 impl<'de> Parser<'de> {
     pub fn new(input: &'de str) -> Self {
         Parser {
-            source: input,
             lexer: Lexer::new(input),
             lookup: Lookup::default(),
         }

From bf9bee3a64823e948582c8e2f9c9c28d9e1f27d6 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Wed, 30 Oct 2024 19:28:16 +0100
Subject: [PATCH 20/43] =?UTF-8?q?=F0=9F=8E=A8=20Fix=20cargo=20clippy=20war?=
 =?UTF-8?q?nings?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/lexer/token.rs   | 2 +-
 src/parser/lookup.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/lexer/token.rs b/src/lexer/token.rs
index 138ad70..581994e 100644
--- a/src/lexer/token.rs
+++ b/src/lexer/token.rs
@@ -8,7 +8,7 @@ pub struct Token<'de> {
     pub span: miette::SourceSpan,
 }
 
-impl<'de> Token<'de> {
+impl Token<'_> {
     pub fn label(&self, text: impl Into<String>) -> miette::LabeledSpan {
         miette::LabeledSpan::at(self.span, text.into())
     }
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index e945550..1d26ee1 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -98,7 +98,7 @@ impl<'de> Lookup<'de> {
     // }
 }
 
-impl<'de> Default for Lookup<'de> {
+impl Default for Lookup<'_> {
     fn default() -> Self {
         Lookup {
             statement_lookup: HashMap::new(),

From 228f751025e34ed3a38da7ac6c13a9c3e9d3c49e Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Wed, 30 Oct 2024 20:57:02 +0100
Subject: [PATCH 21/43] =?UTF-8?q?=E2=9C=A8=20Add=20typing=20system?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: minor
---
 src/lexer/mod.rs        | 16 +++++++++
 src/parser/ast.rs       | 45 +++++++++++++++++++++----
 src/parser/lookup.rs    | 50 +++++++++++++++------------
 src/parser/mod.rs       |  1 +
 src/parser/statement.rs | 71 ++++++++++++++++++++++++++++++++------
 src/parser/typing.rs    | 75 +++++++++++++++++++++++++++++++++++++++++
 6 files changed, 219 insertions(+), 39 deletions(-)
 create mode 100644 src/parser/typing.rs

diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
index 1d1341e..7c05481 100644
--- a/src/lexer/mod.rs
+++ b/src/lexer/mod.rs
@@ -86,6 +86,22 @@ impl<'de> Lexer<'de> {
         self.peeked.as_ref()
     }
 
+    pub fn peek_expect(
+        &mut self,
+        expected: TokenKind,
+    ) -> Option<&Result<Token<'de>, miette::Error>> {
+        match self.peek() {
+            Some(Ok(token::Token { kind, .. })) => {
+                if *kind == expected {
+                    self.peeked.as_ref()
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }
+
     fn parse_compound_operator(
         &mut self,
         single: TokenKind,
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index 8cb62c1..5b6d48c 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -10,23 +10,26 @@ pub enum Symbol<'de> {
 pub enum Statement<'de> {
     Block(Vec<Statement<'de>>),
     Expression(Expression<'de>),
-    Assignment(Cow<'de, str>, Expression<'de>),
+    Assignment {
+        name: Cow<'de, str>,
+        value: Expression<'de>,
+    },
     Struct {
         name: Cow<'de, str>,
-        fields: Vec<Cow<'de, str>>,
+        fields: Vec<StructMemberDeclaration<'de>>,
     },
     Enum {
         name: Cow<'de, str>,
-        variants: Vec<Cow<'de, str>>,
+        variants: Vec<EnumMemberDeclaration<'de>>,
     },
     Function {
-        name: Cow<'de, str>,
-        parameters: Vec<Cow<'de, str>>,
+        header: FunctionHeader<'de>,
         body: Expression<'de>,
+        explicit_return_type: Option<Type<'de>>,
     },
     Trait {
         name: Cow<'de, str>,
-        functions: Vec<(Cow<'de, str>, Vec<Cow<'de, str>>)>,
+        functions: Vec<FunctionHeader<'de>>,
     },
 }
 
@@ -58,6 +61,30 @@ pub enum Expression<'de> {
     },
 }
 
+#[derive(Debug)]
+pub struct FunctionHeader<'de> {
+    pub name: Cow<'de, str>,
+    pub parameters: Vec<ParameterDeclaration<'de>>,
+}
+
+#[derive(Debug)]
+pub struct ParameterDeclaration<'de> {
+    pub name: Cow<'de, str>,
+    pub explicit_type: Type<'de>,
+}
+
+#[derive(Debug)]
+pub struct StructMemberDeclaration<'de> {
+    pub name: Cow<'de, str>,
+    pub explicit_type: Type<'de>,
+}
+
+#[derive(Debug)]
+pub struct EnumMemberDeclaration<'de> {
+    pub name: Cow<'de, str>,
+    pub value_type: Option<Type<'de>>,
+}
+
 #[derive(Debug)]
 pub enum Primitive<'de> {
     Integer(i64),
@@ -91,3 +118,9 @@ pub enum UnaryOperator {
     Negate,
     Negative,
 }
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Type<'de> {
+    Symbol(Cow<'de, str>),
+    Array(Box<Type<'de>>),
+}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 1d26ee1..b77bdf2 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -1,6 +1,6 @@
 use super::{
-    ast::{Expression, Primitive, Statement},
-    expression, statement, Parser,
+    ast::{Expression, Primitive, Statement, Type},
+    expression, statement, typing, Parser,
 };
 use crate::lexer::TokenKind;
 use miette::Result;
@@ -21,9 +21,8 @@ pub enum BindingPower {
     Primary = 10,
 }
 
-// pub type TypeHandler<'de> = fn(&mut Parser<'de>) -> Result<(Type, usize), Error<'de>>;
-// pub type LeftTypeHandler<'de> =
-//     fn(&'de Parser<'de>, usize, Type, &BindingPower) -> Result<(Type, usize), Error<'de>>;
+pub type TypeHandler<'de> = fn(&mut Parser<'de>) -> Result<Type<'de>>;
+pub type LeftTypeHandler<'de> = fn(&mut Parser<'de>, Type, BindingPower) -> Result<Type<'de>>;
 pub type StatementHandler<'de> = fn(&mut Parser<'de>) -> Result<Statement<'de>>;
 pub type ExpressionHandler<'de> = fn(&mut Parser<'de>) -> Result<Expression<'de>>;
 pub type LeftExpressionHandler<'de> =
@@ -33,8 +32,8 @@ pub struct Lookup<'de> {
     pub statement_lookup: HashMap<TokenKind, StatementHandler<'de>>,
     pub expression_lookup: HashMap<TokenKind, ExpressionHandler<'de>>,
     pub left_expression_lookup: HashMap<TokenKind, LeftExpressionHandler<'de>>,
-    // pub type_lookup: HashMap<TokenKind, TypeHandler<'de>>,
-    // pub left_type_lookup: HashMap<TokenKind, LeftTypeHandler<'de>>,
+    pub type_lookup: HashMap<TokenKind, TypeHandler<'de>>,
+    pub left_type_lookup: HashMap<TokenKind, LeftTypeHandler<'de>>,
     pub binding_power_lookup: HashMap<TokenKind, BindingPower>,
 }
 
@@ -80,22 +79,28 @@ impl<'de> Lookup<'de> {
         self
     }
 
-    // pub(crate) fn add_type_handler(&mut self, token: TokenType, handler: TypeHandler<'de>) {
-    //     if self.type_lookup.contains_key(&token) {
-    //         panic!("Token already has a type handler");
-    //     }
+    pub(crate) fn add_type_handler(mut self, token: TokenKind, handler: TypeHandler<'de>) -> Self {
+        if self.type_lookup.contains_key(&token) {
+            panic!("Token already has a type handler");
+        }
 
-    //     self.type_lookup.insert(token, handler);
-    // }
+        self.type_lookup.insert(token, handler);
+        self
+    }
 
-    // #[allow(dead_code)]
-    // pub(crate) fn add_left_type_handler(&mut self, token: TokenType, handler: LeftTypeHandler<'de>) {
-    //     if self.left_type_lookup.contains_key(&token) {
-    //         panic!("Token already has a left type handler");
-    //     }
+    #[allow(dead_code)]
+    pub(crate) fn add_left_type_handler(
+        mut self,
+        token: TokenKind,
+        handler: LeftTypeHandler<'de>,
+    ) -> Self {
+        if self.left_type_lookup.contains_key(&token) {
+            panic!("Token already has a left type handler");
+        }
 
-    //     self.left_type_lookup.insert(token, handler);
-    // }
+        self.left_type_lookup.insert(token, handler);
+        self
+    }
 }
 
 impl Default for Lookup<'_> {
@@ -105,8 +110,8 @@ impl Default for Lookup<'_> {
             expression_lookup: HashMap::new(),
             left_expression_lookup: HashMap::new(),
             binding_power_lookup: HashMap::new(),
-            // type_lookup: HashMap::new(),
-            // left_type_lookup: HashMap::new(),
+            type_lookup: HashMap::new(),
+            left_type_lookup: HashMap::new(),
         }
         .add_expression_handler(TokenKind::Integer, expression::primitive::integer)
         .add_expression_handler(TokenKind::Decimal, expression::primitive::decimal)
@@ -190,6 +195,7 @@ impl Default for Lookup<'_> {
         .add_statement_handler(TokenKind::Enum, statement::enum_)
         .add_statement_handler(TokenKind::Function, statement::function_)
         .add_statement_handler(TokenKind::Trait, statement::trait_)
+        .add_type_handler(TokenKind::Identifier, typing::identifier)
     }
 }
 
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index d683647..04e84ed 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -7,6 +7,7 @@ pub mod ast;
 pub mod expression;
 pub mod lookup;
 pub mod statement;
+pub mod typing;
 
 pub struct Parser<'de> {
     lexer: Lexer<'de>,
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index 62212d0..0443165 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -1,6 +1,14 @@
-use crate::lexer::{TokenKind, TokenValue};
-
-use super::{ast::Statement, expression, lookup::BindingPower, Parser};
+use crate::lexer::{self, TokenKind, TokenValue};
+
+use super::{
+    ast::{
+        EnumMemberDeclaration, FunctionHeader, ParameterDeclaration, Statement,
+        StructMemberDeclaration,
+    },
+    expression,
+    lookup::BindingPower,
+    typing, Parser,
+};
 use miette::{Context, Result};
 
 pub fn parse<'de>(parser: &mut Parser<'de>, optional_semicolon: bool) -> Result<Statement<'de>> {
@@ -62,7 +70,10 @@ pub fn let_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .lexer
         .expect(TokenKind::Semicolon, "expected a semicolon")?;
 
-    Ok(Statement::Assignment(identifier, expression))
+    Ok(Statement::Assignment {
+        name: identifier,
+        value: expression,
+    })
 }
 
 pub fn struct_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
@@ -103,7 +114,14 @@ pub fn struct_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             _ => unreachable!(),
         };
 
-        fields.push(field);
+        parser.lexer.expect(TokenKind::Tilde, "expected a tilde")?;
+
+        let explicit_type = typing::parse(parser, BindingPower::None)?;
+
+        fields.push(StructMemberDeclaration {
+            name: field,
+            explicit_type,
+        });
     }
 
     parser
@@ -154,7 +172,10 @@ pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             _ => unreachable!(),
         };
 
-        variants.push(variant);
+        variants.push(EnumMemberDeclaration {
+            name: variant,
+            value_type: None,
+        });
     }
 
     parser
@@ -207,19 +228,37 @@ pub fn function_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             _ => unreachable!(),
         };
 
-        parameters.push(parameter);
+        parser.lexer.expect(TokenKind::Tilde, "expected a tilde")?;
+
+        let explicit_type = typing::parse(parser, BindingPower::None)?;
+
+        parameters.push(ParameterDeclaration {
+            name: parameter,
+            explicit_type,
+        });
     }
 
     parser
         .lexer
         .expect(TokenKind::ParenClose, "expected a close parenthesis")?;
 
+    let explicit_return_type = match parser.lexer.peek_expect(TokenKind::Tilde) {
+        None => None,
+        Some(_) => {
+            parser.lexer.next();
+            Some(typing::parse(parser, BindingPower::None)?)
+        }
+    };
+
     let body = expression::parse(parser, BindingPower::None)?;
 
     Ok(Statement::Function {
-        name: identifier,
-        parameters,
+        header: FunctionHeader {
+            name: identifier,
+            parameters,
+        },
         body,
+        explicit_return_type,
     })
 }
 
@@ -291,14 +330,24 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
                 _ => unreachable!(),
             };
 
-            parameters.push(parameter);
+            parser.lexer.expect(TokenKind::Tilde, "expected a tilde")?;
+
+            let explicit_type = typing::parse(parser, BindingPower::None)?;
+
+            parameters.push(ParameterDeclaration {
+                name: parameter,
+                explicit_type,
+            });
         }
 
         parser
             .lexer
             .expect(TokenKind::ParenClose, "expected a close parenthesis")?;
 
-        functions.push((function, parameters));
+        functions.push(FunctionHeader {
+            name: function,
+            parameters,
+        })
     }
 
     parser
diff --git a/src/parser/typing.rs b/src/parser/typing.rs
new file mode 100644
index 0000000..ad92eb2
--- /dev/null
+++ b/src/parser/typing.rs
@@ -0,0 +1,75 @@
+use crate::lexer::{TokenKind, TokenValue};
+
+use super::{ast::Type, lookup::BindingPower, Parser};
+use miette::Result;
+
+pub fn parse<'de>(parser: &mut Parser<'de>, binding_power: BindingPower) -> Result<Type<'de>> {
+    let token = match parser.lexer.peek().as_ref() {
+        Some(Ok(token)) => token,
+        Some(Err(err)) => return Err(miette::miette!(err.to_string())), // FIXME: better error handling
+        None => {
+            return Err(miette::miette! {
+                help = "expected a type",
+                "expected a type"
+            })
+        }
+    };
+
+    let handler = parser
+        .lookup
+        .type_lookup
+        .get(&token.kind)
+        .ok_or(miette::miette! {
+            labels = vec![token.label("expected a type")],
+            help = format!("{} is not a type", token.kind),
+            "expected a type, found {}", token.kind
+        })?;
+    let mut lhs = handler(parser)?;
+
+    let mut next_token = parser.lexer.peek();
+
+    while let Some(token) = next_token {
+        let token = match token {
+            Ok(token) => token,
+            Err(err) => return Err(miette::miette!(err.to_string())), // FIXME: better error handling
+        };
+
+        let token_binding_power = {
+            let binding_power_lookup = parser.lookup.binding_power_lookup.clone();
+            binding_power_lookup
+                .get(&token.kind)
+                .unwrap_or(&BindingPower::None)
+                .clone()
+        };
+
+        if binding_power > token_binding_power {
+            break;
+        }
+
+        let handler = match parser.lookup.left_type_lookup.get(&token.kind) {
+            Some(handler) => handler,
+            None => break,
+        };
+
+        parser.lexer.next();
+
+        lhs = handler(parser, lhs, token_binding_power)?;
+
+        next_token = parser.lexer.peek();
+    }
+
+    Ok(lhs)
+}
+
+pub fn identifier<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
+    let token = parser
+        .lexer
+        .expect(TokenKind::Identifier, "expected an identifier")?;
+
+    let identifier = match token.value {
+        TokenValue::Identifier(identifier) => identifier,
+        _ => unreachable!(),
+    };
+
+    Ok(Type::Symbol(identifier))
+}

From 6a9f3bcdc7930c76ac9fae35f3abb64b0d1fef8a Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Wed, 30 Oct 2024 20:57:36 +0100
Subject: [PATCH 22/43] =?UTF-8?q?=F0=9F=92=9A=20Fix=20CI=20workflow?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 .github/workflows/ci.yaml | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 35f4232..dadf35a 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -43,22 +43,22 @@ jobs:
           cargo fmt --all -- --check
           cargo clippy -- -D warnings
 
-      - name: Install cargo check tools
-        run: |
-          cargo install --locked cargo-deny || true
-          cargo install --locked cargo-outdated || true
-          cargo install --locked cargo-udeps || true
-          cargo install --locked cargo-audit || true
-          cargo install --locked cargo-pants || true
+      # - name: Install cargo check tools
+      #   run: |
+      #     cargo install --locked cargo-deny || true
+      #     cargo install --locked cargo-outdated || true
+      #     cargo install --locked cargo-udeps || true
+      #     cargo install --locked cargo-audit || true
+      #     cargo install --locked cargo-pants || true
 
-      - name: Check
-        run: |
-          cargo deny check -c config/cargo-deny.toml
-          cargo outdated
-          cargo udeps
-          rm -rf ~/.cargo/advisory-db
-          cargo audit
-          cargo pants
+      # - name: Check
+      #   run: |
+      #     cargo deny check -c config/cargo-deny.toml
+      #     cargo outdated
+      #     cargo udeps
+      #     rm -rf ~/.cargo/advisory-db
+      #     cargo audit
+      #     cargo pants
 
       - name: Test
         run: cargo test

From e0ad300c8d5c8a5beb7ad3008be2143596352cb3 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Wed, 30 Oct 2024 21:03:18 +0100
Subject: [PATCH 23/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs             |  2 +-
 src/parser/ast.rs       |  4 +++-
 src/parser/lookup.rs    |  3 +++
 src/parser/statement.rs |  3 +--
 src/parser/typing.rs    | 40 ++++++++++++++++++++++++++++++++++++++--
 5 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 16df000..4da81c5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,7 +12,7 @@ fn main() {
         fib(9999);
     }
 
-    fn fib(n ~ number) ~ number {
+    fn fib(n ~ number) ~ [number] {
         return if n < 2;
         fib(n - 1) + fib(n - 2)
     }
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index 5b6d48c..c2712e7 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -121,6 +121,8 @@ pub enum UnaryOperator {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Type<'de> {
+    Unit,
     Symbol(Cow<'de, str>),
-    Array(Box<Type<'de>>),
+    Collection(Box<Type<'de>>),
+    Set(Box<Type<'de>>),
 }
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index b77bdf2..e2af3c0 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -196,6 +196,9 @@ impl Default for Lookup<'_> {
         .add_statement_handler(TokenKind::Function, statement::function_)
         .add_statement_handler(TokenKind::Trait, statement::trait_)
         .add_type_handler(TokenKind::Identifier, typing::identifier)
+        .add_type_handler(TokenKind::ParenOpen, typing::unit)
+        .add_type_handler(TokenKind::SquareOpen, typing::collection)
+        .add_type_handler(TokenKind::CurlyOpen, typing::set)
     }
 }
 
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index 0443165..4d5fcba 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -1,5 +1,3 @@
-use crate::lexer::{self, TokenKind, TokenValue};
-
 use super::{
     ast::{
         EnumMemberDeclaration, FunctionHeader, ParameterDeclaration, Statement,
@@ -9,6 +7,7 @@ use super::{
     lookup::BindingPower,
     typing, Parser,
 };
+use crate::lexer::{TokenKind, TokenValue};
 use miette::{Context, Result};
 
 pub fn parse<'de>(parser: &mut Parser<'de>, optional_semicolon: bool) -> Result<Statement<'de>> {
diff --git a/src/parser/typing.rs b/src/parser/typing.rs
index ad92eb2..363031a 100644
--- a/src/parser/typing.rs
+++ b/src/parser/typing.rs
@@ -1,6 +1,5 @@
-use crate::lexer::{TokenKind, TokenValue};
-
 use super::{ast::Type, lookup::BindingPower, Parser};
+use crate::lexer::{TokenKind, TokenValue};
 use miette::Result;
 
 pub fn parse<'de>(parser: &mut Parser<'de>, binding_power: BindingPower) -> Result<Type<'de>> {
@@ -61,6 +60,43 @@ pub fn parse<'de>(parser: &mut Parser<'de>, binding_power: BindingPower) -> Resu
     Ok(lhs)
 }
 
+pub fn unit<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::ParenOpen, "expected an opening parenthesis")?;
+    parser
+        .lexer
+        .expect(TokenKind::ParenClose, "expected a closing parenthesis")?;
+
+    Ok(Type::Unit)
+}
+
+pub fn collection<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::SquareOpen, "expected an opening bracket")?;
+    let element = parse(parser, BindingPower::None)?;
+    parser
+        .lexer
+        .expect(TokenKind::SquareClose, "expected a closing bracket")?;
+
+    Ok(Type::Collection(Box::new(element)))
+}
+
+pub fn set<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::CurlyOpen, "expected an opening curly brace")?;
+
+    let element = parse(parser, BindingPower::None)?;
+
+    parser
+        .lexer
+        .expect(TokenKind::CurlyClose, "expected a closing curly brace")?;
+
+    Ok(Type::Set(Box::new(element)))
+}
+
 pub fn identifier<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
     let token = parser
         .lexer

From 8f2aa93f304a8a9a37e10c85e8a186f975147431 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Wed, 30 Oct 2024 21:17:40 +0100
Subject: [PATCH 24/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/lexer/mod.rs     |  6 ++++++
 src/lexer/token.rs   | 19 +++++++++++++++++++
 src/main.rs          | 11 ++++++++---
 src/parser/ast.rs    |  5 +++++
 src/parser/lookup.rs |  7 ++++++-
 src/parser/typing.rs | 43 ++++++++++++++++++++++++++++++++++++++++---
 6 files changed, 84 insertions(+), 7 deletions(-)

diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
index 7c05481..88b5c9c 100644
--- a/src/lexer/mod.rs
+++ b/src/lexer/mod.rs
@@ -195,6 +195,12 @@ impl<'de> Iterator for Lexer<'de> {
                     "struct" => Ok((TokenKind::Struct, TokenValue::None)),
                     "enum" => Ok((TokenKind::Enum, TokenValue::None)),
                     "trait" => Ok((TokenKind::Trait, TokenValue::None)),
+                    "bool" => Ok((TokenKind::BooleanType, TokenValue::None)),
+                    "int" => Ok((TokenKind::IntegerType, TokenValue::None)),
+                    "dec" => Ok((TokenKind::DecimalType, TokenValue::None)),
+                    "str" => Ok((TokenKind::StringType, TokenValue::None)),
+                    "char" => Ok((TokenKind::CharacterType, TokenValue::None)),
+                    "()" => Ok((TokenKind::UnitType, TokenValue::None)),
                     ident => Ok((
                         TokenKind::Identifier,
                         TokenValue::Identifier(ident.to_string().into()),
diff --git a/src/lexer/token.rs b/src/lexer/token.rs
index 581994e..970ccca 100644
--- a/src/lexer/token.rs
+++ b/src/lexer/token.rs
@@ -165,6 +165,19 @@ pub enum TokenKind {
     Enum,
     /// A trait keyword; `trait`.
     Trait,
+
+    /// The boolean type; `bool`.
+    BooleanType,
+    /// The integer type; `int`.
+    IntegerType,
+    /// The decimal type; `dec`.
+    DecimalType,
+    /// The string type; `str`.
+    StringType,
+    /// The character type; `char`.
+    CharacterType,
+    /// The unit type; `()`.
+    UnitType,
 }
 
 impl Display for TokenKind {
@@ -221,6 +234,12 @@ impl Display for TokenKind {
             TokenKind::And => write!(f, "`&&`"),
             TokenKind::Or => write!(f, "`||`"),
             TokenKind::Trait => write!(f, "`trait`"),
+            TokenKind::BooleanType => write!(f, "a boolean type"),
+            TokenKind::IntegerType => write!(f, "an integer type"),
+            TokenKind::DecimalType => write!(f, "a decimal type"),
+            TokenKind::StringType => write!(f, "a string type"),
+            TokenKind::CharacterType => write!(f, "a character type"),
+            TokenKind::UnitType => write!(f, "a unit type"),
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 4da81c5..c36b56e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,9 +12,9 @@ fn main() {
         fib(9999);
     }
 
-    fn fib(n ~ number) ~ [number] {
+    fn fib(n ~ int) ~ int {
         return if n < 2;
-        fib(n - 1) + fib(n - 2)
+        fib(n - 1) + fib(n - 20)
     }
         ";
 
@@ -76,7 +76,12 @@ impl miette::highlighters::HighlighterState for SomHighlighterState {
                             Style::new().fg_rgb::<209, 154, 102>()
                         }
                         TokenKind::Boolean => Style::new().fg_rgb::<86, 156, 214>(),
-
+                        TokenKind::IntegerType
+                        | TokenKind::DecimalType
+                        | TokenKind::BooleanType
+                        | TokenKind::StringType
+                        | TokenKind::CharacterType
+                        | TokenKind::UnitType => Style::new().fg_rgb::<86, 156, 214>().italic(),
                         TokenKind::Equal
                         | TokenKind::LessThan
                         | TokenKind::GreaterThan
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index c2712e7..c59bac6 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -122,6 +122,11 @@ pub enum UnaryOperator {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Type<'de> {
     Unit,
+    Boolean,
+    Integer,
+    Decimal,
+    Character,
+    String,
     Symbol(Cow<'de, str>),
     Collection(Box<Type<'de>>),
     Set(Box<Type<'de>>),
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index e2af3c0..e214595 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -196,7 +196,12 @@ impl Default for Lookup<'_> {
         .add_statement_handler(TokenKind::Function, statement::function_)
         .add_statement_handler(TokenKind::Trait, statement::trait_)
         .add_type_handler(TokenKind::Identifier, typing::identifier)
-        .add_type_handler(TokenKind::ParenOpen, typing::unit)
+        .add_type_handler(TokenKind::UnitType, typing::unit)
+        .add_type_handler(TokenKind::CharacterType, typing::character)
+        .add_type_handler(TokenKind::BooleanType, typing::boolean)
+        .add_type_handler(TokenKind::IntegerType, typing::integer)
+        .add_type_handler(TokenKind::DecimalType, typing::decimal)
+        .add_type_handler(TokenKind::StringType, typing::string)
         .add_type_handler(TokenKind::SquareOpen, typing::collection)
         .add_type_handler(TokenKind::CurlyOpen, typing::set)
     }
diff --git a/src/parser/typing.rs b/src/parser/typing.rs
index 363031a..10e673b 100644
--- a/src/parser/typing.rs
+++ b/src/parser/typing.rs
@@ -63,12 +63,49 @@ pub fn parse<'de>(parser: &mut Parser<'de>, binding_power: BindingPower) -> Resu
 pub fn unit<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
     parser
         .lexer
-        .expect(TokenKind::ParenOpen, "expected an opening parenthesis")?;
+        .expect(TokenKind::UnitType, "expected an unit type")?;
+
+    Ok(Type::Unit)
+}
+
+pub fn boolean<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
     parser
         .lexer
-        .expect(TokenKind::ParenClose, "expected a closing parenthesis")?;
+        .expect(TokenKind::BooleanType, "expected a boolean type")?;
 
-    Ok(Type::Unit)
+    Ok(Type::Boolean)
+}
+
+pub fn integer<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::IntegerType, "expected an integer type")?;
+
+    Ok(Type::Integer)
+}
+
+pub fn decimal<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::DecimalType, "expected a decimal type")?;
+
+    Ok(Type::Decimal)
+}
+
+pub fn string<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::StringType, "expected a string type")?;
+
+    Ok(Type::String)
+}
+
+pub fn character<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::CharacterType, "expected a character type")?;
+
+    Ok(Type::Character)
 }
 
 pub fn collection<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {

From 290acf379a6f1bd8e0ed23af4dcfe368f3aada0c Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Thu, 31 Oct 2024 00:26:25 +0100
Subject: [PATCH 25/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/lexer/mod.rs         |  1 -
 src/lexer/token.rs       |  3 ---
 src/main.rs              | 39 +++++++++++++++++++++++++--------------
 src/parser/lookup.rs     |  2 +-
 src/parser/typing.rs     |  6 +++++-
 src/passer/mod.rs        | 13 +++++++++++++
 src/passer/typing/mod.rs | 23 +++++++++++++++++++++++
 7 files changed, 67 insertions(+), 20 deletions(-)
 create mode 100644 src/passer/mod.rs
 create mode 100644 src/passer/typing/mod.rs

diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
index 88b5c9c..3f7a7f6 100644
--- a/src/lexer/mod.rs
+++ b/src/lexer/mod.rs
@@ -200,7 +200,6 @@ impl<'de> Iterator for Lexer<'de> {
                     "dec" => Ok((TokenKind::DecimalType, TokenValue::None)),
                     "str" => Ok((TokenKind::StringType, TokenValue::None)),
                     "char" => Ok((TokenKind::CharacterType, TokenValue::None)),
-                    "()" => Ok((TokenKind::UnitType, TokenValue::None)),
                     ident => Ok((
                         TokenKind::Identifier,
                         TokenValue::Identifier(ident.to_string().into()),
diff --git a/src/lexer/token.rs b/src/lexer/token.rs
index 970ccca..fe6bbc3 100644
--- a/src/lexer/token.rs
+++ b/src/lexer/token.rs
@@ -176,8 +176,6 @@ pub enum TokenKind {
     StringType,
     /// The character type; `char`.
     CharacterType,
-    /// The unit type; `()`.
-    UnitType,
 }
 
 impl Display for TokenKind {
@@ -239,7 +237,6 @@ impl Display for TokenKind {
             TokenKind::DecimalType => write!(f, "a decimal type"),
             TokenKind::StringType => write!(f, "a string type"),
             TokenKind::CharacterType => write!(f, "a character type"),
-            TokenKind::UnitType => write!(f, "a unit type"),
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index c36b56e..944343c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,23 +1,14 @@
 use lexer::{Lexer, TokenKind};
 use owo_colors::{Style, Styled};
 use parser::Parser;
+use passer::Passer;
 use std::vec;
 
 pub mod lexer;
 pub mod parser;
+pub mod passer;
 
 fn main() {
-    let input = "
-    fn main() {
-        fib(9999);
-    }
-
-    fn fib(n ~ int) ~ int {
-        return if n < 2;
-        fib(n - 1) + fib(n - 20)
-    }
-        ";
-
     miette::set_hook(Box::new(|_| {
         Box::new(
             miette::MietteHandlerOpts::new()
@@ -30,6 +21,17 @@ fn main() {
     }))
     .unwrap();
 
+    let input = "
+    fn main() {
+        fib(9999);
+    }
+
+    fn fib(n ~ int) ~ int {
+        return n if n < 2;
+        fib(n - 1) + fib(n - 20)
+    }
+        ";
+
     let mut parser = Parser::new(input);
     let symbol = match parser.parse() {
         Ok(symbol) => symbol,
@@ -39,7 +41,15 @@ fn main() {
         }
     };
 
-    println!("{:?}", symbol);
+    let typing_pass = passer::typing::TypingPasser::pass(&symbol).unwrap();
+
+    for note in typing_pass.non_critical {
+        println!("{:?}", note.with_source_code(input.to_string()));
+    }
+
+    for note in typing_pass.critical {
+        println!("{:?}", note.with_source_code(input.to_string()));
+    }
 }
 
 struct SomHighlighter {}
@@ -80,8 +90,9 @@ impl miette::highlighters::HighlighterState for SomHighlighterState {
                         | TokenKind::DecimalType
                         | TokenKind::BooleanType
                         | TokenKind::StringType
-                        | TokenKind::CharacterType
-                        | TokenKind::UnitType => Style::new().fg_rgb::<86, 156, 214>().italic(),
+                        | TokenKind::CharacterType => {
+                            Style::new().fg_rgb::<86, 156, 214>().italic()
+                        }
                         TokenKind::Equal
                         | TokenKind::LessThan
                         | TokenKind::GreaterThan
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index e214595..3977343 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -196,7 +196,7 @@ impl Default for Lookup<'_> {
         .add_statement_handler(TokenKind::Function, statement::function_)
         .add_statement_handler(TokenKind::Trait, statement::trait_)
         .add_type_handler(TokenKind::Identifier, typing::identifier)
-        .add_type_handler(TokenKind::UnitType, typing::unit)
+        .add_type_handler(TokenKind::ParenOpen, typing::unit)
         .add_type_handler(TokenKind::CharacterType, typing::character)
         .add_type_handler(TokenKind::BooleanType, typing::boolean)
         .add_type_handler(TokenKind::IntegerType, typing::integer)
diff --git a/src/parser/typing.rs b/src/parser/typing.rs
index 10e673b..7c44fa9 100644
--- a/src/parser/typing.rs
+++ b/src/parser/typing.rs
@@ -63,7 +63,11 @@ pub fn parse<'de>(parser: &mut Parser<'de>, binding_power: BindingPower) -> Resu
 pub fn unit<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
     parser
         .lexer
-        .expect(TokenKind::UnitType, "expected an unit type")?;
+        .expect(TokenKind::ParenOpen, "expected an opening parenthesis")?;
+
+    parser
+        .lexer
+        .expect(TokenKind::ParenClose, "expected a closing parenthesis")?;
 
     Ok(Type::Unit)
 }
diff --git a/src/passer/mod.rs b/src/passer/mod.rs
new file mode 100644
index 0000000..5626037
--- /dev/null
+++ b/src/passer/mod.rs
@@ -0,0 +1,13 @@
+use crate::parser::ast::Symbol;
+use miette::{Report, Result};
+
+pub mod typing;
+
+pub trait Passer {
+    fn pass(ast: &Symbol<'_>) -> Result<PasserResult>;
+}
+
+pub struct PasserResult {
+    pub non_critical: Vec<Report>,
+    pub critical: Vec<Report>,
+}
diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
new file mode 100644
index 0000000..e126b41
--- /dev/null
+++ b/src/passer/typing/mod.rs
@@ -0,0 +1,23 @@
+use super::{Passer, PasserResult};
+use crate::parser::ast::Symbol;
+use miette::{Result, Severity};
+
+pub struct TypingPasser;
+
+impl Passer for TypingPasser {
+    fn pass(ast: &Symbol<'_>) -> Result<PasserResult> {
+        let mut critical = vec![];
+        let mut non_critical = vec![];
+
+        non_critical.push(miette::miette! {
+            severity = Severity::Warning,
+            labels = vec![miette::LabeledSpan::at(100, "uwu")],
+            "Typing is not yet implemented"
+        });
+
+        Ok(PasserResult {
+            critical,
+            non_critical,
+        })
+    }
+}

From 2f4e41f6de5a4f0f08a86ddf0c810b3ef49688d0 Mon Sep 17 00:00:00 2001
From: Lucas de Jong <lucas.dejong@cofano.nl>
Date: Thu, 31 Oct 2024 15:33:11 +0100
Subject: [PATCH 26/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/lexer/mod.rs         |  1 +
 src/main.rs              | 57 +++++++++++++++++++++++++++-------------
 src/parser/ast.rs        | 10 +++++--
 src/parser/lookup.rs     | 27 +++++++++----------
 src/parser/statement.rs  | 39 ++++++++++++++++++++++++++-
 src/passer/typing/mod.rs | 53 ++++++++++++++++++++++++++++++++-----
 6 files changed, 144 insertions(+), 43 deletions(-)

diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
index 3f7a7f6..ebf8097 100644
--- a/src/lexer/mod.rs
+++ b/src/lexer/mod.rs
@@ -200,6 +200,7 @@ impl<'de> Iterator for Lexer<'de> {
                     "dec" => Ok((TokenKind::DecimalType, TokenValue::None)),
                     "str" => Ok((TokenKind::StringType, TokenValue::None)),
                     "char" => Ok((TokenKind::CharacterType, TokenValue::None)),
+                    "return" => Ok((TokenKind::Return, TokenValue::None)),
                     ident => Ok((
                         TokenKind::Identifier,
                         TokenValue::Identifier(ident.to_string().into()),
diff --git a/src/main.rs b/src/main.rs
index 944343c..0f3c371 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,7 +1,10 @@
 use lexer::{Lexer, TokenKind};
 use owo_colors::{Style, Styled};
-use parser::Parser;
-use passer::Passer;
+use parser::{
+    ast::{Expression, Statement},
+    Parser,
+};
+use passer::{typing::Typing, Passer};
 use std::vec;
 
 pub mod lexer;
@@ -21,15 +24,7 @@ fn main() {
     }))
     .unwrap();
 
-    let input = "
-    fn main() {
-        fib(9999);
-    }
-
-    fn fib(n ~ int) ~ int {
-        return n if n < 2;
-        fib(n - 1) + fib(n - 20)
-    }
+    let input = "true if true else 12 if true else 'h';
         ";
 
     let mut parser = Parser::new(input);
@@ -41,14 +36,39 @@ fn main() {
         }
     };
 
-    let typing_pass = passer::typing::TypingPasser::pass(&symbol).unwrap();
-
-    for note in typing_pass.non_critical {
-        println!("{:?}", note.with_source_code(input.to_string()));
+    match symbol {
+        parser::ast::Symbol::Statement(statement) => print_statement(statement),
+        parser::ast::Symbol::Expression(expression) => print_expression(expression),
     }
 
-    for note in typing_pass.critical {
-        println!("{:?}", note.with_source_code(input.to_string()));
+    // let typing_pass = passer::typing::TypingPasser::pass(&symbol).unwrap();
+
+    // for note in typing_pass.non_critical {
+    //     println!("{:?}", note.with_source_code(input.to_string()));
+    // }
+
+    // for note in typing_pass.critical {
+    //     println!("{:?}", note.with_source_code(input.to_string()));
+    // }
+}
+
+fn print_expression(expression: Expression) {
+    println!(
+        "{:?} of type ({:?})",
+        expression,
+        expression.possible_types()
+    );
+}
+
+fn print_statement(statement: Statement) {
+    match statement {
+        Statement::Block(statements) => {
+            for statement in statements {
+                print_statement(statement);
+            }
+        }
+        Statement::Expression(expression) => print_expression(expression),
+        _ => println!("{:?}", statement),
     }
 }
 
@@ -79,7 +99,8 @@ impl miette::highlighters::HighlighterState for SomHighlighterState {
                         | TokenKind::Struct
                         | TokenKind::Enum
                         | TokenKind::Function
-                        | TokenKind::Trait => Style::new().fg_rgb::<197, 120, 221>(),
+                        | TokenKind::Trait
+                        | TokenKind::Return => Style::new().fg_rgb::<197, 120, 221>(),
                         TokenKind::Identifier => Style::new().fg_rgb::<224, 108, 117>(),
                         TokenKind::String => Style::new().fg_rgb::<152, 195, 121>().italic(),
                         TokenKind::Integer | TokenKind::Decimal => {
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index c59bac6..37d1f4a 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -31,6 +31,12 @@ pub enum Statement<'de> {
         name: Cow<'de, str>,
         functions: Vec<FunctionHeader<'de>>,
     },
+    Return(Expression<'de>),
+    Conditional {
+        condition: Box<Expression<'de>>,
+        truthy: Box<Statement<'de>>,
+        falsy: Option<Box<Statement<'de>>>,
+    },
 }
 
 #[derive(Debug)]
@@ -50,10 +56,10 @@ pub enum Expression<'de> {
         statements: Vec<Statement<'de>>,
         return_value: Box<Expression<'de>>,
     },
-    If {
+    Conditional {
         condition: Box<Expression<'de>>,
         truthy: Box<Expression<'de>>,
-        falsy: Option<Box<Expression<'de>>>,
+        falsy: Box<Expression<'de>>,
     },
     Call {
         callee: Box<Expression<'de>>,
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 3977343..d451f52 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -120,7 +120,7 @@ impl Default for Lookup<'_> {
         .add_expression_handler(TokenKind::String, expression::primitive::string)
         .add_expression_handler(TokenKind::Identifier, expression::primitive::identifier)
         .add_expression_handler(TokenKind::ParenOpen, group)
-        .add_left_expression_handler(TokenKind::If, BindingPower::None, if_)
+        .add_left_expression_handler(TokenKind::If, BindingPower::None, conditional)
         .add_left_expression_handler(TokenKind::ParenOpen, BindingPower::None, expression::call)
         .add_expression_handler(TokenKind::Not, expression::unary::negate)
         .add_expression_handler(TokenKind::Minus, expression::unary::negative)
@@ -204,31 +204,28 @@ impl Default for Lookup<'_> {
         .add_type_handler(TokenKind::StringType, typing::string)
         .add_type_handler(TokenKind::SquareOpen, typing::collection)
         .add_type_handler(TokenKind::CurlyOpen, typing::set)
+        .add_statement_handler(TokenKind::Return, statement::return_)
+        .add_statement_handler(TokenKind::If, statement::if_)
     }
 }
 
-fn if_<'de>(
+fn conditional<'de>(
     parser: &mut Parser<'de>,
     lhs: Expression<'de>,
     binding_power: BindingPower,
 ) -> Result<Expression<'de>> {
-    let condition = expression::parse(parser, binding_power)?;
+    let condition = expression::parse(parser, binding_power.clone())?;
 
-    let falsy = if parser.lexer.peek().map_or(false, |token| {
-        token
-            .as_ref()
-            .map_or(false, |token| token.kind == TokenKind::Else)
-    }) {
-        parser.lexer.next();
-        Some(expression::parse(parser, BindingPower::None)?)
-    } else {
-        None
-    };
+    parser
+        .lexer
+        .expect(TokenKind::Else, "expected an else branch")?;
+
+    let falsy = expression::parse(parser, binding_power)?;
 
-    Ok(Expression::If {
+    Ok(Expression::Conditional {
         condition: Box::new(condition),
         truthy: Box::new(lhs),
-        falsy: falsy.map(Box::new),
+        falsy: Box::new(falsy),
     })
 }
 
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index 4d5fcba..1b7e766 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -5,7 +5,7 @@ use super::{
     },
     expression,
     lookup::BindingPower,
-    typing, Parser,
+    statement, typing, Parser,
 };
 use crate::lexer::{TokenKind, TokenValue};
 use miette::{Context, Result};
@@ -358,3 +358,40 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         functions,
     })
 }
+
+pub fn return_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::Return, "expected a return keyword")?;
+
+    let expression = expression::parse(parser, BindingPower::None)?;
+
+    Ok(Statement::Return(expression))
+}
+
+pub fn if_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
+    parser
+        .lexer
+        .expect(TokenKind::If, "expected an if keyword")?;
+
+    let condition = expression::parse(parser, BindingPower::None)?;
+
+    let truthy = statement::parse(parser, true)?;
+
+    let falsy = if parser.lexer.peek().map_or(false, |token| {
+        token
+            .as_ref()
+            .map_or(false, |token| token.kind == TokenKind::Else)
+    }) {
+        parser.lexer.next();
+        Some(statement::parse(parser, true)?)
+    } else {
+        None
+    };
+
+    Ok(Statement::Conditional {
+        condition: Box::new(condition),
+        truthy: Box::new(truthy),
+        falsy: falsy.map(Box::new),
+    })
+}
diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
index e126b41..4ff33ce 100644
--- a/src/passer/typing/mod.rs
+++ b/src/passer/typing/mod.rs
@@ -1,5 +1,5 @@
 use super::{Passer, PasserResult};
-use crate::parser::ast::Symbol;
+use crate::parser::ast::{Expression, Statement, Symbol, Type};
 use miette::{Result, Severity};
 
 pub struct TypingPasser;
@@ -9,15 +9,54 @@ impl Passer for TypingPasser {
         let mut critical = vec![];
         let mut non_critical = vec![];
 
-        non_critical.push(miette::miette! {
-            severity = Severity::Warning,
-            labels = vec![miette::LabeledSpan::at(100, "uwu")],
-            "Typing is not yet implemented"
-        });
-
         Ok(PasserResult {
             critical,
             non_critical,
         })
     }
 }
+
+pub trait Typing {
+    fn possible_types(&self) -> Vec<Type>;
+}
+
+impl Typing for Expression<'_> {
+    fn possible_types(&self) -> Vec<Type> {
+        match self {
+            Expression::Primitive(primitive) => vec![match primitive {
+                crate::parser::ast::Primitive::Integer(_) => Type::Integer,
+                crate::parser::ast::Primitive::Decimal(_) => Type::Decimal,
+                crate::parser::ast::Primitive::String(_) => Type::String,
+                crate::parser::ast::Primitive::Identifier(value) => Type::Symbol(value.clone()),
+                crate::parser::ast::Primitive::Character(_) => Type::Character,
+                crate::parser::ast::Primitive::Boolean(_) => Type::Boolean,
+                crate::parser::ast::Primitive::Unit => Type::Unit,
+            }],
+            Expression::Binary {
+                operator,
+                left,
+                right,
+            } => {
+                let mut types = left.possible_types();
+                types.extend(right.possible_types());
+                types
+            }
+            Expression::Unary { operator, operand } => operand.possible_types(),
+            Expression::Group(expression) => expression.possible_types(),
+            Expression::Block {
+                statements,
+                return_value,
+            } => return_value.possible_types(),
+            Expression::Conditional {
+                condition,
+                truthy,
+                falsy,
+            } => {
+                let mut types = truthy.possible_types();
+                types.extend(falsy.possible_types());
+                types
+            }
+            Expression::Call { callee, arguments } => callee.possible_types(),
+        }
+    }
+}

From 8a4f44b8d5a0fd23cd332d8989c5398e134b1a59 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Thu, 31 Oct 2024 16:17:45 +0100
Subject: [PATCH 27/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 0f3c371..a6d139d 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -24,7 +24,14 @@ fn main() {
     }))
     .unwrap();
 
-    let input = "true if true else 12 if true else 'h';
+    let input = " fn main() {
+        fib(9999);
+    }
+
+    fn fib(n ~ int) ~ int {
+        if n < 2 return n;
+        fib(n - 1) + fib(n - 20)
+    }
         ";
 
     let mut parser = Parser::new(input);
@@ -67,8 +74,9 @@ fn print_statement(statement: Statement) {
                 print_statement(statement);
             }
         }
+        Statement::Return(expression) => print_expression(expression),
         Statement::Expression(expression) => print_expression(expression),
-        _ => println!("{:?}", statement),
+        _ => {}
     }
 }
 

From 2a5be64923dfe45c82ebb98f330b406d309bd253 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Thu, 31 Oct 2024 17:30:38 +0100
Subject: [PATCH 28/43] =?UTF-8?q?=F0=9F=90=9B=20Fix=20debug=20typing=20pri?=
 =?UTF-8?q?nting?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: patch
---
 src/main.rs             | 39 +++++++++++++++++++++++++++++----------
 src/parser/ast.rs       | 20 ++++++++++----------
 src/parser/statement.rs |  4 ----
 3 files changed, 39 insertions(+), 24 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index a6d139d..a7bd084 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -24,11 +24,14 @@ fn main() {
     }))
     .unwrap();
 
-    let input = " fn main() {
+    let input = "
+    fn main() {
         fib(9999);
     }
 
     fn fib(n ~ int) ~ int {
+        let n = 12;
+
         if n < 2 return n;
         fib(n - 1) + fib(n - 20)
     }
@@ -43,7 +46,7 @@ fn main() {
         }
     };
 
-    match symbol {
+    match &symbol {
         parser::ast::Symbol::Statement(statement) => print_statement(statement),
         parser::ast::Symbol::Expression(expression) => print_expression(expression),
     }
@@ -59,25 +62,41 @@ fn main() {
     // }
 }
 
-fn print_expression(expression: Expression) {
-    println!(
-        "{:?} of type ({:?})",
-        expression,
-        expression.possible_types()
-    );
+fn print_expression(expression: &Expression) {
+    match &expression {
+        Expression::Block {
+            statements,
+            return_value,
+        } => {
+            for statement in statements {
+                print_statement(statement);
+            }
+            print_expression(return_value);
+        }
+        Expression::Group(expression) => print_expression(expression),
+        e => println!("{:?} typeof {:?}", e, e.possible_types()),
+    }
 }
 
-fn print_statement(statement: Statement) {
+fn print_statement(statement: &Statement) {
     match statement {
         Statement::Block(statements) => {
             for statement in statements {
                 print_statement(statement);
             }
         }
+        Statement::Function {
+            header,
+            body,
+            explicit_return_type,
+        } => {
+            print_expression(body);
+        }
         Statement::Return(expression) => print_expression(expression),
         Statement::Expression(expression) => print_expression(expression),
+        Statement::Assignment { name, value } => print_expression(value),
         _ => {}
-    }
+    };
 }
 
 struct SomHighlighter {}
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index 37d1f4a..b8afe58 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -1,12 +1,12 @@
 use std::borrow::Cow;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Symbol<'de> {
     Statement(Statement<'de>),
     Expression(Expression<'de>),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Statement<'de> {
     Block(Vec<Statement<'de>>),
     Expression(Expression<'de>),
@@ -39,7 +39,7 @@ pub enum Statement<'de> {
     },
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Expression<'de> {
     Primitive(Primitive<'de>),
     Binary {
@@ -67,31 +67,31 @@ pub enum Expression<'de> {
     },
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct FunctionHeader<'de> {
     pub name: Cow<'de, str>,
     pub parameters: Vec<ParameterDeclaration<'de>>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ParameterDeclaration<'de> {
     pub name: Cow<'de, str>,
     pub explicit_type: Type<'de>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct StructMemberDeclaration<'de> {
     pub name: Cow<'de, str>,
     pub explicit_type: Type<'de>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct EnumMemberDeclaration<'de> {
     pub name: Cow<'de, str>,
     pub value_type: Option<Type<'de>>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Primitive<'de> {
     Integer(i64),
     Decimal(f64),
@@ -102,7 +102,7 @@ pub enum Primitive<'de> {
     Unit,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum BinaryOperator {
     Add,
     Subtract,
@@ -119,7 +119,7 @@ pub enum BinaryOperator {
     Or,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum UnaryOperator {
     Negate,
     Negative,
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index 1b7e766..9f7eb4d 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -65,10 +65,6 @@ pub fn let_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .expect(TokenKind::Equal, "expected an equal sign")?;
     let expression = expression::parse(parser, BindingPower::None)?;
 
-    parser
-        .lexer
-        .expect(TokenKind::Semicolon, "expected a semicolon")?;
-
     Ok(Statement::Assignment {
         name: identifier,
         value: expression,

From fdb5b4ef532c0e8248cbba61789ca78fd2dba1af Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Fri, 1 Nov 2024 08:28:24 +0100
Subject: [PATCH 29/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs                        | 86 ++++++++--------------------
 src/parser/ast.rs                  | 44 ++++++++++++++-
 src/parser/expression/binary.rs    | 15 +++--
 src/parser/expression/mod.rs       | 16 ++++--
 src/parser/expression/primitive.rs | 32 ++++++++---
 src/parser/expression/unary.rs     | 28 ++++++----
 src/parser/lookup.rs               | 60 +++++++++++++-------
 src/passer/typing/mod.rs           | 90 ++++++++++++++++++++----------
 8 files changed, 228 insertions(+), 143 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index a7bd084..01c9744 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,7 +1,7 @@
 use lexer::{Lexer, TokenKind};
 use owo_colors::{Style, Styled};
 use parser::{
-    ast::{Expression, Statement},
+    ast::{Expression, ExpressionValue, Statement},
     Parser,
 };
 use passer::{typing::Typing, Passer};
@@ -11,6 +11,19 @@ pub mod lexer;
 pub mod parser;
 pub mod passer;
 
+const INPUT: &str = "
+fn main() {
+    fib(9999);
+}
+
+fn fib(n ~ int) ~ int {
+    let n = 12;
+
+    if n < 2 return n;
+    fib(n - 1) + fib(n - 20)
+}
+";
+
 fn main() {
     miette::set_hook(Box::new(|_| {
         Box::new(
@@ -24,79 +37,24 @@ fn main() {
     }))
     .unwrap();
 
-    let input = "
-    fn main() {
-        fib(9999);
-    }
-
-    fn fib(n ~ int) ~ int {
-        let n = 12;
-
-        if n < 2 return n;
-        fib(n - 1) + fib(n - 20)
-    }
-        ";
-
-    let mut parser = Parser::new(input);
+    let mut parser = Parser::new(INPUT);
     let symbol = match parser.parse() {
         Ok(symbol) => symbol,
         Err(err) => {
-            println!("{:?}", err.with_source_code(input.to_string()));
+            println!("{:?}", err.with_source_code(INPUT));
             return;
         }
     };
 
-    match &symbol {
-        parser::ast::Symbol::Statement(statement) => print_statement(statement),
-        parser::ast::Symbol::Expression(expression) => print_expression(expression),
-    }
-
-    // let typing_pass = passer::typing::TypingPasser::pass(&symbol).unwrap();
-
-    // for note in typing_pass.non_critical {
-    //     println!("{:?}", note.with_source_code(input.to_string()));
-    // }
-
-    // for note in typing_pass.critical {
-    //     println!("{:?}", note.with_source_code(input.to_string()));
-    // }
-}
+    let typing_pass = passer::typing::TypingPasser::pass(&symbol).unwrap();
 
-fn print_expression(expression: &Expression) {
-    match &expression {
-        Expression::Block {
-            statements,
-            return_value,
-        } => {
-            for statement in statements {
-                print_statement(statement);
-            }
-            print_expression(return_value);
-        }
-        Expression::Group(expression) => print_expression(expression),
-        e => println!("{:?} typeof {:?}", e, e.possible_types()),
+    for note in typing_pass.non_critical {
+        println!("{:?}", note.with_source_code(INPUT));
     }
-}
 
-fn print_statement(statement: &Statement) {
-    match statement {
-        Statement::Block(statements) => {
-            for statement in statements {
-                print_statement(statement);
-            }
-        }
-        Statement::Function {
-            header,
-            body,
-            explicit_return_type,
-        } => {
-            print_expression(body);
-        }
-        Statement::Return(expression) => print_expression(expression),
-        Statement::Expression(expression) => print_expression(expression),
-        Statement::Assignment { name, value } => print_expression(value),
-        _ => {}
-    };
+    for note in typing_pass.critical {
+        println!("{:?}", note.with_source_code(INPUT));
+    }
 }
 
 struct SomHighlighter {}
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index b8afe58..e171ffa 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -1,5 +1,7 @@
 use std::borrow::Cow;
 
+use miette::SourceSpan;
+
 #[derive(Debug, Clone)]
 pub enum Symbol<'de> {
     Statement(Statement<'de>),
@@ -40,7 +42,47 @@ pub enum Statement<'de> {
 }
 
 #[derive(Debug, Clone)]
-pub enum Expression<'de> {
+pub struct Expression<'de> {
+    pub value: ExpressionValue<'de>,
+    pub span: miette::SourceSpan,
+}
+
+impl<'de> Expression<'de> {
+    pub fn at(span: miette::SourceSpan, value: ExpressionValue<'de>) -> Self {
+        Self { value, span }
+    }
+
+    pub fn at_multiple(
+        spans: Vec<impl Into<miette::SourceSpan>>,
+        value: ExpressionValue<'de>,
+    ) -> Expression<'de> {
+        let spans = spans.into_iter().map(|s| s.into()).collect::<Vec<_>>();
+
+        let start = spans
+            .iter()
+            .min_by_key(|s| s.offset())
+            .map(|s| s.offset())
+            .unwrap_or(0);
+
+        // Go through all the spans and find the one with the highest end offset
+        let end = spans
+            .iter()
+            .max_by_key(|s| s.offset() + s.len())
+            .map(|s| s.offset() + s.len())
+            .unwrap_or(0);
+
+        let span = miette::SourceSpan::new(start.into(), end - start);
+
+        Expression::at(span, value)
+    }
+
+    pub fn label(&self, text: impl Into<String>) -> miette::LabeledSpan {
+        miette::LabeledSpan::at(self.span, text.into())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ExpressionValue<'de> {
     Primitive(Primitive<'de>),
     Binary {
         operator: BinaryOperator,
diff --git a/src/parser/expression/binary.rs b/src/parser/expression/binary.rs
index b1b2cb8..35ef41f 100644
--- a/src/parser/expression/binary.rs
+++ b/src/parser/expression/binary.rs
@@ -1,5 +1,5 @@
 use crate::parser::{
-    ast::{BinaryOperator, Expression},
+    ast::{BinaryOperator, Expression, ExpressionValue},
     lookup::BindingPower,
     Parser,
 };
@@ -13,11 +13,14 @@ pub fn parse_binary_expression<'de>(
 ) -> Result<Expression<'de>> {
     let rhs = crate::parser::expression::parse(parser, bp)?;
 
-    Ok(Expression::Binary {
-        operator,
-        left: Box::new(lhs),
-        right: Box::new(rhs),
-    })
+    Ok(Expression::at_multiple(
+        vec![rhs.span, lhs.span],
+        ExpressionValue::Binary {
+            operator,
+            left: Box::new(lhs),
+            right: Box::new(rhs),
+        },
+    ))
 }
 
 pub fn addition<'de>(
diff --git a/src/parser/expression/mod.rs b/src/parser/expression/mod.rs
index 8850455..b14a22f 100644
--- a/src/parser/expression/mod.rs
+++ b/src/parser/expression/mod.rs
@@ -1,6 +1,9 @@
 use miette::Result;
 
-use super::{ast::Expression, Parser};
+use super::{
+    ast::{Expression, ExpressionValue},
+    Parser,
+};
 use crate::{lexer::TokenKind, parser::lookup::BindingPower};
 
 pub mod binary;
@@ -94,8 +97,11 @@ pub fn call<'de>(
         .lexer
         .expect(TokenKind::ParenClose, "expected a closing parenthesis")?;
 
-    Ok(Expression::Call {
-        callee: Box::new(lhs),
-        arguments,
-    })
+    Ok(Expression::at(
+        lhs.span,
+        ExpressionValue::Call {
+            callee: Box::new(lhs.clone()),
+            arguments,
+        },
+    ))
 }
diff --git a/src/parser/expression/primitive.rs b/src/parser/expression/primitive.rs
index a234364..5fd33be 100644
--- a/src/parser/expression/primitive.rs
+++ b/src/parser/expression/primitive.rs
@@ -1,7 +1,7 @@
 use crate::{
     lexer::{TokenKind, TokenValue},
     parser::{
-        ast::{Expression, Primitive},
+        ast::{Expression, ExpressionValue, Primitive},
         Parser,
     },
 };
@@ -17,7 +17,10 @@ pub fn integer<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
         _ => unreachable!(),
     };
 
-    Ok(Expression::Primitive(Primitive::Integer(value)))
+    Ok(Expression::at(
+        token.span,
+        ExpressionValue::Primitive(Primitive::Integer(value)),
+    ))
 }
 
 pub fn decimal<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
@@ -30,7 +33,10 @@ pub fn decimal<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
         _ => unreachable!(),
     };
 
-    Ok(Expression::Primitive(Primitive::Decimal(value)))
+    Ok(Expression::at(
+        token.span,
+        ExpressionValue::Primitive(Primitive::Decimal(value)),
+    ))
 }
 
 pub fn boolean<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
@@ -43,7 +49,10 @@ pub fn boolean<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
         _ => unreachable!(),
     };
 
-    Ok(Expression::Primitive(Primitive::Boolean(value)))
+    Ok(Expression::at(
+        token.span,
+        ExpressionValue::Primitive(Primitive::Boolean(value)),
+    ))
 }
 
 pub fn character<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
@@ -56,7 +65,10 @@ pub fn character<'de>(parser: &mut Parser) -> Result<Expression<'de>> {
         _ => unreachable!(),
     };
 
-    Ok(Expression::Primitive(Primitive::Character(value)))
+    Ok(Expression::at(
+        token.span,
+        ExpressionValue::Primitive(Primitive::Character(value)),
+    ))
 }
 
 pub fn string<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
@@ -69,7 +81,10 @@ pub fn string<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
         _ => unreachable!(),
     };
 
-    Ok(Expression::Primitive(Primitive::String(value)))
+    Ok(Expression::at(
+        token.span,
+        ExpressionValue::Primitive(Primitive::String(value)),
+    ))
 }
 
 pub fn identifier<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
@@ -82,5 +97,8 @@ pub fn identifier<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
         _ => unreachable!(),
     };
 
-    Ok(Expression::Primitive(Primitive::Identifier(value)))
+    Ok(Expression::at(
+        token.span,
+        ExpressionValue::Primitive(Primitive::Identifier(value)),
+    ))
 }
diff --git a/src/parser/expression/unary.rs b/src/parser/expression/unary.rs
index c5de31f..bf64043 100644
--- a/src/parser/expression/unary.rs
+++ b/src/parser/expression/unary.rs
@@ -1,7 +1,7 @@
 use crate::{
     lexer::TokenKind,
     parser::{
-        ast::{Expression, UnaryOperator},
+        ast::{Expression, ExpressionValue, UnaryOperator},
         lookup::BindingPower,
         Parser,
     },
@@ -9,25 +9,31 @@ use crate::{
 use miette::Result;
 
 pub fn negate<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::Not, "expected a negate operator")?;
     let expression = crate::parser::expression::parse(parser, BindingPower::None)?;
 
-    Ok(Expression::Unary {
-        operator: UnaryOperator::Negate,
-        operand: Box::new(expression),
-    })
+    Ok(Expression::at_multiple(
+        vec![token.span, expression.span],
+        ExpressionValue::Unary {
+            operator: UnaryOperator::Negate,
+            operand: Box::new(expression),
+        },
+    ))
 }
 
 pub fn negative<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::Minus, "expected a negative operator")?;
     let expression = crate::parser::expression::parse(parser, BindingPower::None)?;
 
-    Ok(Expression::Unary {
-        operator: UnaryOperator::Negative,
-        operand: Box::new(expression),
-    })
+    Ok(Expression::at_multiple(
+        vec![token.span, expression.span],
+        ExpressionValue::Unary {
+            operator: UnaryOperator::Negative,
+            operand: Box::new(expression),
+        },
+    ))
 }
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index d451f52..5e75a8b 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -1,9 +1,9 @@
 use super::{
-    ast::{Expression, Primitive, Statement, Type},
+    ast::{Expression, ExpressionValue, Primitive, Statement, Type},
     expression, statement, typing, Parser,
 };
-use crate::lexer::TokenKind;
-use miette::Result;
+use crate::lexer::{TokenKind, TokenValue};
+use miette::{Result, SourceSpan};
 use std::collections::HashMap;
 
 #[derive(Debug, Clone, PartialEq, PartialOrd)]
@@ -216,33 +216,39 @@ fn conditional<'de>(
 ) -> Result<Expression<'de>> {
     let condition = expression::parse(parser, binding_power.clone())?;
 
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::Else, "expected an else branch")?;
 
     let falsy = expression::parse(parser, binding_power)?;
 
-    Ok(Expression::Conditional {
-        condition: Box::new(condition),
-        truthy: Box::new(lhs),
-        falsy: Box::new(falsy),
-    })
+    Ok(Expression::at_multiple(
+        vec![condition.span, token.span, falsy.span],
+        ExpressionValue::Conditional {
+            condition: Box::new(condition),
+            truthy: Box::new(lhs),
+            falsy: Box::new(falsy),
+        },
+    ))
 }
 
 fn group<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
-    parser
+    let open = parser
         .lexer
         .expect(TokenKind::ParenOpen, "expected a left parenthesis")?;
     let expression = expression::parse(parser, BindingPower::None)?;
-    parser
+    let close = parser
         .lexer
         .expect(TokenKind::ParenClose, "expected a right parenthesis")?;
 
-    Ok(Expression::Group(Box::new(expression)))
+    Ok(Expression::at_multiple(
+        vec![open.span, expression.span, close.span],
+        ExpressionValue::Group(Box::new(expression)),
+    ))
 }
 
 fn block<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
-    parser
+    let open = parser
         .lexer
         .expect(TokenKind::CurlyOpen, "expected a left curly brace")?;
 
@@ -286,20 +292,32 @@ fn block<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
                 Some(Statement::Expression(expression)) => expression,
                 _ => unreachable!(),
             },
-            _ => Expression::Primitive(Primitive::Unit),
+            _ => Expression::at(
+                SourceSpan::new(0.into(), 0),
+                ExpressionValue::Primitive(Primitive::Unit),
+            ),
         }
     } else {
-        Expression::Primitive(Primitive::Unit)
+        Expression::at(
+            SourceSpan::new(0.into(), 0),
+            ExpressionValue::Primitive(Primitive::Unit),
+        )
     };
 
-    let expression = Expression::Block {
-        statements,
-        return_value: Box::new(return_value),
-    };
+    let expression = Expression::at(
+        return_value.span,
+        ExpressionValue::Block {
+            statements,
+            return_value: Box::new(return_value),
+        },
+    );
 
-    parser
+    let close = parser
         .lexer
         .expect(TokenKind::CurlyClose, "expected a right curly brace")?;
 
-    Ok(Expression::Group(Box::new(expression)))
+    Ok(Expression::at_multiple(
+        vec![open.span, close.span],
+        ExpressionValue::Group(Box::new(expression)),
+    ))
 }
diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
index 4ff33ce..113a81d 100644
--- a/src/passer/typing/mod.rs
+++ b/src/passer/typing/mod.rs
@@ -1,39 +1,67 @@
 use super::{Passer, PasserResult};
-use crate::parser::ast::{Expression, Statement, Symbol, Type};
-use miette::{Result, Severity};
+use crate::parser::{
+    ast::{Expression, ExpressionValue, Statement, Symbol, Type},
+    expression,
+};
+use miette::{Error, LabeledSpan, Report, Result};
 
 pub struct TypingPasser;
 
 impl Passer for TypingPasser {
     fn pass(ast: &Symbol<'_>) -> Result<PasserResult> {
-        let mut critical = vec![];
-        let mut non_critical = vec![];
+       todo!()
+    }
+}
+
 
-        Ok(PasserResult {
-            critical,
-            non_critical,
-        })
+pub fn walk_statement<'de>(statement: &Statement<'de>, statement_fn: fn(&Statement<'de>, expression_fn: fn(&Expression<'de>)) {
+    match statement {
+        Statement::Block(statements) => statements.iter().for_each(|statement| {
+            walk_statement(statement, statement_fn);
+        }),
+        Statement::Expression(expression) => walk_expression(expression),
+        Statement::Assignment { name, value } => walk_expression(expression, expression_fn),
+        Statement::Struct { name, fields } => todo!(),
+        Statement::Enum { name, variants } => todo!(),
+        Statement::Function {
+            header,
+            body,
+            explicit_return_type,
+        } => todo!(),
+        Statement::Trait { name, functions } => todo!(),
+        Statement::Return(expression) => todo!(),
+        Statement::Conditional {
+            condition,
+            truthy,
+            falsy,
+        } => todo!(),
     }
 }
 
+pub fn walk_expression<'de, T>(expression: Expression<'de>, statement_fn: fn(&Statement<'de>, expression_fn: fn(&Expression<'de>)) {
+
+}
+
 pub trait Typing {
-    fn possible_types(&self) -> Vec<Type>;
+    fn possible_types(&self) -> Vec<(Type, miette::SourceSpan)>;
 }
 
 impl Typing for Expression<'_> {
-    fn possible_types(&self) -> Vec<Type> {
-        match self {
-            Expression::Primitive(primitive) => vec![match primitive {
-                crate::parser::ast::Primitive::Integer(_) => Type::Integer,
-                crate::parser::ast::Primitive::Decimal(_) => Type::Decimal,
-                crate::parser::ast::Primitive::String(_) => Type::String,
-                crate::parser::ast::Primitive::Identifier(value) => Type::Symbol(value.clone()),
-                crate::parser::ast::Primitive::Character(_) => Type::Character,
-                crate::parser::ast::Primitive::Boolean(_) => Type::Boolean,
-                crate::parser::ast::Primitive::Unit => Type::Unit,
+    fn possible_types(&self) -> Vec<(Type, miette::SourceSpan)> {
+        match &self.value {
+            ExpressionValue::Primitive(primitive) => vec![match primitive {
+                crate::parser::ast::Primitive::Integer(_) => (Type::Integer, self.span),
+                crate::parser::ast::Primitive::Decimal(_) => (Type::Decimal, self.span),
+                crate::parser::ast::Primitive::String(_) => (Type::String, self.span),
+                crate::parser::ast::Primitive::Identifier(value) => {
+                    (Type::Symbol(value.clone()), self.span)
+                }
+                crate::parser::ast::Primitive::Character(_) => (Type::Character, self.span),
+                crate::parser::ast::Primitive::Boolean(_) => (Type::Boolean, self.span),
+                crate::parser::ast::Primitive::Unit => (Type::Unit, self.span),
             }],
-            Expression::Binary {
-                operator,
+            ExpressionValue::Binary {
+                operator: _,
                 left,
                 right,
             } => {
@@ -41,14 +69,17 @@ impl Typing for Expression<'_> {
                 types.extend(right.possible_types());
                 types
             }
-            Expression::Unary { operator, operand } => operand.possible_types(),
-            Expression::Group(expression) => expression.possible_types(),
-            Expression::Block {
-                statements,
+            ExpressionValue::Unary {
+                operator: _,
+                operand,
+            } => operand.possible_types(),
+            ExpressionValue::Group(expression) => expression.possible_types(),
+            ExpressionValue::Block {
+                statements: _,
                 return_value,
             } => return_value.possible_types(),
-            Expression::Conditional {
-                condition,
+            ExpressionValue::Conditional {
+                condition: _,
                 truthy,
                 falsy,
             } => {
@@ -56,7 +87,10 @@ impl Typing for Expression<'_> {
                 types.extend(falsy.possible_types());
                 types
             }
-            Expression::Call { callee, arguments } => callee.possible_types(),
+            ExpressionValue::Call {
+                callee,
+                arguments: _,
+            } => callee.possible_types(),
         }
     }
 }

From 4f4db628cd17a366a31528e548d8b010f55c31aa Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Fri, 1 Nov 2024 15:34:16 +0100
Subject: [PATCH 30/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/parser/ast.rs                  | 102 ++++++++++++++++++-----------
 src/parser/expression/binary.rs    |   2 +-
 src/parser/expression/mod.rs       |   2 +-
 src/parser/expression/primitive.rs |   2 +-
 src/parser/expression/unary.rs     |   2 +-
 src/parser/lookup.rs               |   8 +--
 src/parser/mod.rs                  |   7 +-
 src/parser/statement.rs            |  66 +++++++++++--------
 src/passer/typing/mod.rs           |  55 +++++++++++++---
 9 files changed, 161 insertions(+), 85 deletions(-)

diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index e171ffa..a07f8a3 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -9,7 +9,13 @@ pub enum Symbol<'de> {
 }
 
 #[derive(Debug, Clone)]
-pub enum Statement<'de> {
+pub struct Statement<'de> {
+    pub value: StatementValue<'de>,
+    pub span: miette::SourceSpan,
+}
+
+#[derive(Debug, Clone)]
+pub enum StatementValue<'de> {
     Block(Vec<Statement<'de>>),
     Expression(Expression<'de>),
     Assignment {
@@ -27,7 +33,6 @@ pub enum Statement<'de> {
     Function {
         header: FunctionHeader<'de>,
         body: Expression<'de>,
-        explicit_return_type: Option<Type<'de>>,
     },
     Trait {
         name: Cow<'de, str>,
@@ -47,40 +52,6 @@ pub struct Expression<'de> {
     pub span: miette::SourceSpan,
 }
 
-impl<'de> Expression<'de> {
-    pub fn at(span: miette::SourceSpan, value: ExpressionValue<'de>) -> Self {
-        Self { value, span }
-    }
-
-    pub fn at_multiple(
-        spans: Vec<impl Into<miette::SourceSpan>>,
-        value: ExpressionValue<'de>,
-    ) -> Expression<'de> {
-        let spans = spans.into_iter().map(|s| s.into()).collect::<Vec<_>>();
-
-        let start = spans
-            .iter()
-            .min_by_key(|s| s.offset())
-            .map(|s| s.offset())
-            .unwrap_or(0);
-
-        // Go through all the spans and find the one with the highest end offset
-        let end = spans
-            .iter()
-            .max_by_key(|s| s.offset() + s.len())
-            .map(|s| s.offset() + s.len())
-            .unwrap_or(0);
-
-        let span = miette::SourceSpan::new(start.into(), end - start);
-
-        Expression::at(span, value)
-    }
-
-    pub fn label(&self, text: impl Into<String>) -> miette::LabeledSpan {
-        miette::LabeledSpan::at(self.span, text.into())
-    }
-}
-
 #[derive(Debug, Clone)]
 pub enum ExpressionValue<'de> {
     Primitive(Primitive<'de>),
@@ -113,6 +84,7 @@ pub enum ExpressionValue<'de> {
 pub struct FunctionHeader<'de> {
     pub name: Cow<'de, str>,
     pub parameters: Vec<ParameterDeclaration<'de>>,
+    pub explicit_return_type: Option<Type<'de>>,
 }
 
 #[derive(Debug, Clone)]
@@ -168,7 +140,13 @@ pub enum UnaryOperator {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Type<'de> {
+pub struct Type<'de> {
+    pub value: TypeValue<'de>,
+    pub span: SourceSpan,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TypeValue<'de> {
     Unit,
     Boolean,
     Integer,
@@ -179,3 +157,53 @@ pub enum Type<'de> {
     Collection(Box<Type<'de>>),
     Set(Box<Type<'de>>),
 }
+
+pub trait Spannable<'de>: Sized {
+    type Value;
+
+    fn at(span: miette::SourceSpan, value: Self::Value) -> Self;
+
+    fn at_multiple(spans: Vec<impl Into<miette::SourceSpan>>, value: Self::Value) -> Self {
+        let spans = spans.into_iter().map(|s| s.into()).collect::<Vec<_>>();
+
+        let start = spans
+            .iter()
+            .min_by_key(|s| s.offset())
+            .map(|s| s.offset())
+            .unwrap_or(0);
+
+        let end = spans
+            .iter()
+            .max_by_key(|s| s.offset() + s.len())
+            .map(|s| s.offset() + s.len())
+            .unwrap_or(0);
+
+        let span = miette::SourceSpan::new(start.into(), end - start);
+
+        Self::at(span, value)
+    }
+}
+
+impl<'de> Spannable<'de> for Expression<'de> {
+    type Value = ExpressionValue<'de>;
+
+    fn at(span: miette::SourceSpan, value: Self::Value) -> Self {
+        Self { value, span }
+    }
+}
+
+impl<'de> Spannable<'de> for Statement<'de> {
+    type Value = StatementValue<'de>;
+
+    fn at(span: miette::SourceSpan, value: Self::Value) -> Self {
+        Self { value, span }
+    }
+}
+
+impl<'de> Spannable<'de> for Type<'de> {
+    type Value = TypeValue<'de>;
+
+    fn at(span: miette::SourceSpan, value: Self::Value) -> Self {
+        Self { value, span }
+    }
+}
diff --git a/src/parser/expression/binary.rs b/src/parser/expression/binary.rs
index 35ef41f..edb5078 100644
--- a/src/parser/expression/binary.rs
+++ b/src/parser/expression/binary.rs
@@ -1,5 +1,5 @@
 use crate::parser::{
-    ast::{BinaryOperator, Expression, ExpressionValue},
+    ast::{BinaryOperator, Expression, ExpressionValue, Spannable},
     lookup::BindingPower,
     Parser,
 };
diff --git a/src/parser/expression/mod.rs b/src/parser/expression/mod.rs
index b14a22f..45f7aa7 100644
--- a/src/parser/expression/mod.rs
+++ b/src/parser/expression/mod.rs
@@ -1,7 +1,7 @@
 use miette::Result;
 
 use super::{
-    ast::{Expression, ExpressionValue},
+    ast::{Expression, ExpressionValue, Spannable},
     Parser,
 };
 use crate::{lexer::TokenKind, parser::lookup::BindingPower};
diff --git a/src/parser/expression/primitive.rs b/src/parser/expression/primitive.rs
index 5fd33be..cf004c5 100644
--- a/src/parser/expression/primitive.rs
+++ b/src/parser/expression/primitive.rs
@@ -1,7 +1,7 @@
 use crate::{
     lexer::{TokenKind, TokenValue},
     parser::{
-        ast::{Expression, ExpressionValue, Primitive},
+        ast::{Expression, ExpressionValue, Primitive, Spannable},
         Parser,
     },
 };
diff --git a/src/parser/expression/unary.rs b/src/parser/expression/unary.rs
index bf64043..dbc414d 100644
--- a/src/parser/expression/unary.rs
+++ b/src/parser/expression/unary.rs
@@ -1,7 +1,7 @@
 use crate::{
     lexer::TokenKind,
     parser::{
-        ast::{Expression, ExpressionValue, UnaryOperator},
+        ast::{Expression, ExpressionValue, Spannable, UnaryOperator},
         lookup::BindingPower,
         Parser,
     },
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 5e75a8b..a9d7cea 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -1,5 +1,5 @@
 use super::{
-    ast::{Expression, ExpressionValue, Primitive, Statement, Type},
+    ast::{Expression, ExpressionValue, Primitive, Spannable, Statement, StatementValue, Type},
     expression, statement, typing, Parser,
 };
 use crate::lexer::{TokenKind, TokenValue};
@@ -287,9 +287,9 @@ fn block<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
     }
 
     let return_value = if last_is_return {
-        match statements.last() {
-            Some(Statement::Expression(_)) => match statements.pop() {
-                Some(Statement::Expression(expression)) => expression,
+        match statements.last().map(|s| &s.value) {
+            Some(StatementValue::Expression(_)) => match statements.pop().map(|s| s.value) {
+                Some(StatementValue::Expression(expression)) => expression,
                 _ => unreachable!(),
             },
             _ => Expression::at(
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index 04e84ed..f952b08 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -1,5 +1,5 @@
 use crate::lexer::Lexer;
-use ast::{Statement, Symbol};
+use ast::{Spannable, Statement, StatementValue, Symbol};
 use lookup::Lookup;
 use miette::Result;
 
@@ -29,6 +29,9 @@ impl<'de> Parser<'de> {
             statements.push(statement::parse(self, false)?);
         }
 
-        Ok(Symbol::Statement(Statement::Block(statements)))
+        Ok(Symbol::Statement(Statement::at_multiple(
+            statements.iter().map(|s| s.span).collect(),
+            StatementValue::Block(statements),
+        )))
     }
 }
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index 9f7eb4d..4ac44d6 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -1,13 +1,13 @@
 use super::{
     ast::{
-        EnumMemberDeclaration, FunctionHeader, ParameterDeclaration, Statement,
-        StructMemberDeclaration,
+        EnumMemberDeclaration, FunctionHeader, ParameterDeclaration, Spannable, Statement,
+        StatementValue, StructMemberDeclaration,
     },
     expression,
     lookup::BindingPower,
     statement, typing, Parser,
 };
-use crate::lexer::{TokenKind, TokenValue};
+use crate::lexer::{Token, TokenKind, TokenValue};
 use miette::{Context, Result};
 
 pub fn parse<'de>(parser: &mut Parser<'de>, optional_semicolon: bool) -> Result<Statement<'de>> {
@@ -33,16 +33,21 @@ pub fn parse<'de>(parser: &mut Parser<'de>, optional_semicolon: bool) -> Result<
                 .wrap_err("while parsing a statement")?;
 
             if !optional_semicolon {
-                parser
+                let token = parser
                     .lexer
                     .expect(
                         TokenKind::Semicolon,
                         "expected a semicolon at the end of an expression",
                     )
                     .wrap_err(format!("while parsing for {}", token_kind))?;
-            }
 
-            Statement::Expression(expression)
+                Statement::at_multiple(
+                    vec![expression.span, token.span],
+                    StatementValue::Expression(expression),
+                )
+            } else {
+                Statement::at(expression.span, StatementValue::Expression(expression))
+            }
         }
     };
 
@@ -50,13 +55,13 @@ pub fn parse<'de>(parser: &mut Parser<'de>, optional_semicolon: bool) -> Result<
 }
 
 pub fn let_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::Let, "expected a let keyword")?;
     let identifier = parser
         .lexer
         .expect(TokenKind::Identifier, "expected a variable name")?;
-    let identifier = match identifier.value {
+    let name = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
         _ => unreachable!(),
     };
@@ -65,14 +70,17 @@ pub fn let_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .expect(TokenKind::Equal, "expected an equal sign")?;
     let expression = expression::parse(parser, BindingPower::None)?;
 
-    Ok(Statement::Assignment {
-        name: identifier,
-        value: expression,
-    })
+    Ok(Statement::at_multiple(
+        vec![token.span, identifier.span],
+        StatementValue::Assignment {
+            name,
+            value: expression,
+        },
+    ))
 }
 
 pub fn struct_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::Struct, "expected a struct keyword")?;
 
@@ -80,7 +88,7 @@ pub fn struct_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .lexer
         .expect(TokenKind::Identifier, "expected a struct name")?;
 
-    let identifier = match identifier.value {
+    let name = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
         _ => unreachable!(),
     };
@@ -123,14 +131,14 @@ pub fn struct_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .lexer
         .expect(TokenKind::Semicolon, "expected a semicolon")?;
 
-    Ok(Statement::Struct {
-        name: identifier,
-        fields,
-    })
+    Ok(Statement::at_multiple(
+        vec![token.span, identifier.span],
+        StatementValue::Struct { name, fields },
+    ))
 }
 
 pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::Enum, "expected an enum keyword")?;
 
@@ -138,7 +146,7 @@ pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .lexer
         .expect(TokenKind::Identifier, "expected an enum name")?;
 
-    let identifier = match identifier.value {
+    let name = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
         _ => unreachable!(),
     };
@@ -177,14 +185,14 @@ pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .lexer
         .expect(TokenKind::Semicolon, "expected a semicolon")?;
 
-    Ok(Statement::Enum {
-        name: identifier,
-        variants,
-    })
+    Ok(Statement::at_multiple(
+        vec![token.span, identifier.span],
+        StatementValue::Enum { name, variants },
+    ))
 }
 
 pub fn function_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::Function, "expected a function keyword")?;
 
@@ -192,7 +200,7 @@ pub fn function_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .lexer
         .expect(TokenKind::Identifier, "expected function name")?;
 
-    let identifier = match identifier.value {
+    let name = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
         _ => unreachable!(),
     };
@@ -247,13 +255,13 @@ pub fn function_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
 
     let body = expression::parse(parser, BindingPower::None)?;
 
-    Ok(Statement::Function {
+    Ok(Statement::at_multiple(vec![], value)::Function {
         header: FunctionHeader {
-            name: identifier,
+            name,
             parameters,
+            explicit_return_type,
         },
         body,
-        explicit_return_type,
     })
 }
 
diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
index 113a81d..b59d56d 100644
--- a/src/passer/typing/mod.rs
+++ b/src/passer/typing/mod.rs
@@ -1,6 +1,6 @@
 use super::{Passer, PasserResult};
 use crate::parser::{
-    ast::{Expression, ExpressionValue, Statement, Symbol, Type},
+    ast::{Expression, ExpressionValue, Statement, StatementValue, Symbol, Type},
     expression,
 };
 use miette::{Error, LabeledSpan, Report, Result};
@@ -14,20 +14,20 @@ impl Passer for TypingPasser {
 }
 
 
-pub fn walk_statement<'de>(statement: &Statement<'de>, statement_fn: fn(&Statement<'de>, expression_fn: fn(&Expression<'de>)) {
+pub fn walk_statement<'de>(statement: &Statement<'de>, statement_fn: fn(&Statement<'de>), expression_fn: fn(&Expression<'de>)) {
     match statement {
         Statement::Block(statements) => statements.iter().for_each(|statement| {
-            walk_statement(statement, statement_fn);
+            walk_statement(statement, statement_fn, expression_fn);
         }),
-        Statement::Expression(expression) => walk_expression(expression),
+        Statement::Expression(expression) => walk_expression(statement_fn, expression_fn),
         Statement::Assignment { name, value } => walk_expression(expression, expression_fn),
-        Statement::Struct { name, fields } => todo!(),
-        Statement::Enum { name, variants } => todo!(),
+        Statement::Struct { name, fields } => {},
+        Statement::Enum { name, variants } => {},
         Statement::Function {
             header,
             body,
             explicit_return_type,
-        } => todo!(),
+        } => ,
         Statement::Trait { name, functions } => todo!(),
         Statement::Return(expression) => todo!(),
         Statement::Conditional {
@@ -38,8 +38,8 @@ pub fn walk_statement<'de>(statement: &Statement<'de>, statement_fn: fn(&Stateme
     }
 }
 
-pub fn walk_expression<'de, T>(expression: Expression<'de>, statement_fn: fn(&Statement<'de>, expression_fn: fn(&Expression<'de>)) {
-
+pub fn walk_expression<'de, T>(expression: Expression<'de>, statement_fn: fn(&Statement<'de>, expression_fn: fn(&Expression<'de>))) {
+    todo!()
 }
 
 pub trait Typing {
@@ -94,3 +94,40 @@ impl Typing for Expression<'_> {
         }
     }
 }
+
+impl Typing for Statement<'_> {
+    fn possible_types(&self) -> Vec<(Type, miette::SourceSpan)> {
+        match &self.value {
+            StatementValue::Block(statements) => vec![],
+            StatementValue::Expression(expression) => expression.possible_types(),
+            StatementValue::Assignment { name: _, value } => value.possible_types(),
+            StatementValue::Struct { name, fields } => vec![(Type::Symbol(name.clone()), self.span)],
+            StatementValue::Enum { name, variants } => vec![(Type::Symbol(name.clone()), self.span)],
+            StatementValue::Function {
+                header: _,
+                body,
+               
+            } => {
+                let mut types = body.possible_types();
+                if let Some(explicit_return_type) = explicit_return_type {
+                    types.push((explicit_return_type,));
+                }
+                types
+            }
+            StatementValue::Trait { name, functions } => vec![(Type::Symbol(name.clone()), self.span)],
+            StatementValue::Return(expression) => expression.possible_types(),
+            StatementValue::Conditional {
+                condition,
+                truthy,
+                falsy,
+            } => {
+                let mut types = condition.possible_types();
+                types.extend(truthy.possible_types());
+                if let Some(falsy) = falsy {
+                    types.extend(falsy.possible_types());
+                }
+                types
+            }
+        }
+    }
+}

From bd3c1e1949935657cb7380c691a62ebc0b3b52ae Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Fri, 1 Nov 2024 15:47:51 +0100
Subject: [PATCH 31/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/passer/typing/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
index b59d56d..ec94ec7 100644
--- a/src/passer/typing/mod.rs
+++ b/src/passer/typing/mod.rs
@@ -1,6 +1,6 @@
 use super::{Passer, PasserResult};
 use crate::parser::{
-    ast::{Expression, ExpressionValue, Statement, StatementValue, Symbol, Type},
+    ast::{Expression, ExpressionValue, Spannable, Statement, StatementValue, Symbol, Type, TypeValue},
     expression,
 };
 use miette::{Error, LabeledSpan, Report, Result};
@@ -50,7 +50,7 @@ impl Typing for Expression<'_> {
     fn possible_types(&self) -> Vec<(Type, miette::SourceSpan)> {
         match &self.value {
             ExpressionValue::Primitive(primitive) => vec![match primitive {
-                crate::parser::ast::Primitive::Integer(_) => (Type::Integer, self.span),
+                crate::parser::ast::Primitive::Integer(_) => Type::at(self.span, TypeValue::Integer),
                 crate::parser::ast::Primitive::Decimal(_) => (Type::Decimal, self.span),
                 crate::parser::ast::Primitive::String(_) => (Type::String, self.span),
                 crate::parser::ast::Primitive::Identifier(value) => {

From 8a13341fdb6f8767909a3fb03375b163eefacfee Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Sat, 2 Nov 2024 16:08:16 +0100
Subject: [PATCH 32/43] =?UTF-8?q?=E2=9C=A8=20Add=20primitive=20type=20chec?=
 =?UTF-8?q?ker?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: minor
---
 src/main.rs              |  15 +--
 src/parser/ast.rs        |  18 ++-
 src/parser/statement.rs  | 231 +++++++++++++++---------------------
 src/parser/typing.rs     |  57 +++++----
 src/passer/mod.rs        |  14 ++-
 src/passer/typing/mod.rs | 245 +++++++++++++++++++++++++++++++--------
 6 files changed, 360 insertions(+), 220 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 01c9744..3959ce4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,16 +12,7 @@ pub mod parser;
 pub mod passer;
 
 const INPUT: &str = "
-fn main() {
-    fib(9999);
-}
-
-fn fib(n ~ int) ~ int {
-    let n = 12;
-
-    if n < 2 return n;
-    fib(n - 1) + fib(n - 20)
-}
+let a = 1 + 1.1 - true * 'c' / \"hello\"
 ";
 
 fn main() {
@@ -87,7 +78,9 @@ impl miette::highlighters::HighlighterState for SomHighlighterState {
                         | TokenKind::Trait
                         | TokenKind::Return => Style::new().fg_rgb::<197, 120, 221>(),
                         TokenKind::Identifier => Style::new().fg_rgb::<224, 108, 117>(),
-                        TokenKind::String => Style::new().fg_rgb::<152, 195, 121>().italic(),
+                        TokenKind::String | TokenKind::Character => {
+                            Style::new().fg_rgb::<152, 195, 121>().italic()
+                        }
                         TokenKind::Integer | TokenKind::Decimal => {
                             Style::new().fg_rgb::<209, 154, 102>()
                         }
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index a07f8a3..d32e4b3 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -1,4 +1,4 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, fmt::Display};
 
 use miette::SourceSpan;
 
@@ -158,6 +158,22 @@ pub enum TypeValue<'de> {
     Set(Box<Type<'de>>),
 }
 
+impl Display for Type<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.value {
+            TypeValue::Unit => write!(f, "an unit"),
+            TypeValue::Boolean => write!(f, "a boolean"),
+            TypeValue::Integer => write!(f, "an integer"),
+            TypeValue::Decimal => write!(f, "a decimal"),
+            TypeValue::Character => write!(f, "a character"),
+            TypeValue::String => write!(f, "a string"),
+            TypeValue::Symbol(name) => write!(f, "{}", name),
+            TypeValue::Collection(element) => write!(f, "[{}]", element),
+            TypeValue::Set(element) => write!(f, "{{{}}}", element),
+        }
+    }
+}
+
 pub trait Spannable<'de>: Sized {
     type Value;
 
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index 4ac44d6..cb0f2d9 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -192,77 +192,13 @@ pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
 }
 
 pub fn function_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
-    let token = parser
-        .lexer
-        .expect(TokenKind::Function, "expected a function keyword")?;
-
-    let identifier = parser
-        .lexer
-        .expect(TokenKind::Identifier, "expected function name")?;
-
-    let name = match identifier.value {
-        TokenValue::Identifier(identifier) => identifier,
-        _ => unreachable!(),
-    };
-
-    parser
-        .lexer
-        .expect(TokenKind::ParenOpen, "expected an open parenthesis")?;
-
-    let mut parameters = vec![];
-
-    while parser.lexer.peek().map_or(false, |token| {
-        token
-            .as_ref()
-            .map_or(false, |token| token.kind != TokenKind::ParenClose)
-    }) {
-        if !parameters.is_empty() {
-            parser
-                .lexer
-                .expect(TokenKind::Comma, "expected a comma between parameters")?;
-        }
-
-        let parameter = parser
-            .lexer
-            .expect(TokenKind::Identifier, "expected a parameter name")?;
-
-        let parameter = match parameter.value {
-            TokenValue::Identifier(parameter) => parameter,
-            _ => unreachable!(),
-        };
-
-        parser.lexer.expect(TokenKind::Tilde, "expected a tilde")?;
-
-        let explicit_type = typing::parse(parser, BindingPower::None)?;
-
-        parameters.push(ParameterDeclaration {
-            name: parameter,
-            explicit_type,
-        });
-    }
-
-    parser
-        .lexer
-        .expect(TokenKind::ParenClose, "expected a close parenthesis")?;
-
-    let explicit_return_type = match parser.lexer.peek_expect(TokenKind::Tilde) {
-        None => None,
-        Some(_) => {
-            parser.lexer.next();
-            Some(typing::parse(parser, BindingPower::None)?)
-        }
-    };
-
+    let header = parse_function_header(parser)?;
     let body = expression::parse(parser, BindingPower::None)?;
 
-    Ok(Statement::at_multiple(vec![], value)::Function {
-        header: FunctionHeader {
-            name,
-            parameters,
-            explicit_return_type,
-        },
-        body,
-    })
+    Ok(Statement::at_multiple(
+        vec![body.span],
+        StatementValue::Function { header, body },
+    ))
 }
 
 pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
@@ -274,7 +210,7 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .lexer
         .expect(TokenKind::Identifier, "expected a trait name")?;
 
-    let identifier = match identifier.value {
+    let name = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
         _ => unreachable!(),
     };
@@ -294,87 +230,34 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
                 .expect(TokenKind::Comma, "expected a comma between functions")?;
         }
 
-        parser
-            .lexer
-            .expect(TokenKind::Function, "expected a function keyword")?;
-
-        let function = parser
-            .lexer
-            .expect(TokenKind::Identifier, "expected a function name")?;
-
-        let function = match function.value {
-            TokenValue::Identifier(function) => function,
-            _ => unreachable!(),
-        };
-
-        parser
-            .lexer
-            .expect(TokenKind::ParenOpen, "expected an open parenthesis")?;
-
-        let mut parameters = vec![];
-
-        while parser.lexer.peek().map_or(false, |token| {
-            token
-                .as_ref()
-                .map_or(false, |token| token.kind != TokenKind::ParenClose)
-        }) {
-            if !parameters.is_empty() {
-                parser
-                    .lexer
-                    .expect(TokenKind::Comma, "expected a comma in between arguments")?;
-            }
-
-            let parameter = parser
-                .lexer
-                .expect(TokenKind::Identifier, "expected an argument name")?;
-
-            let parameter = match parameter.value {
-                TokenValue::Identifier(parameter) => parameter,
-                _ => unreachable!(),
-            };
-
-            parser.lexer.expect(TokenKind::Tilde, "expected a tilde")?;
-
-            let explicit_type = typing::parse(parser, BindingPower::None)?;
-
-            parameters.push(ParameterDeclaration {
-                name: parameter,
-                explicit_type,
-            });
-        }
-
-        parser
-            .lexer
-            .expect(TokenKind::ParenClose, "expected a close parenthesis")?;
-
-        functions.push(FunctionHeader {
-            name: function,
-            parameters,
-        })
+        functions.push(parse_function_header(parser)?);
     }
 
     parser
         .lexer
         .expect(TokenKind::Semicolon, "expected a semicolon")?;
 
-    Ok(Statement::Trait {
-        name: identifier,
-        functions,
-    })
+    Ok(Statement::at_multiple(
+        vec![identifier.span],
+        StatementValue::Trait { name, functions },
+    ))
 }
 
 pub fn return_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::Return, "expected a return keyword")?;
 
     let expression = expression::parse(parser, BindingPower::None)?;
 
-    Ok(Statement::Return(expression))
+    Ok(Statement::at_multiple(
+        vec![token.span, expression.span],
+        StatementValue::Return(expression),
+    ))
 }
 
 pub fn if_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::If, "expected an if keyword")?;
 
@@ -393,9 +276,81 @@ pub fn if_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         None
     };
 
-    Ok(Statement::Conditional {
-        condition: Box::new(condition),
-        truthy: Box::new(truthy),
-        falsy: falsy.map(Box::new),
+    Ok(Statement::at_multiple(
+        vec![token.span, condition.span],
+        StatementValue::Conditional {
+            condition: Box::new(condition),
+            truthy: Box::new(truthy),
+            falsy: falsy.map(Box::new),
+        },
+    ))
+}
+
+fn parse_function_header<'de>(parser: &mut Parser<'de>) -> Result<FunctionHeader<'de>> {
+    let token = parser
+        .lexer
+        .expect(TokenKind::Function, "expected a function keyword")?;
+
+    let identifier = parser
+        .lexer
+        .expect(TokenKind::Identifier, "expected function name")?;
+
+    let name = match identifier.value {
+        TokenValue::Identifier(identifier) => identifier,
+        _ => unreachable!(),
+    };
+
+    parser
+        .lexer
+        .expect(TokenKind::ParenOpen, "expected an open parenthesis")?;
+
+    let mut parameters = vec![];
+
+    while parser.lexer.peek().map_or(false, |token| {
+        token
+            .as_ref()
+            .map_or(false, |token| token.kind != TokenKind::ParenClose)
+    }) {
+        if !parameters.is_empty() {
+            parser
+                .lexer
+                .expect(TokenKind::Comma, "expected a comma between parameters")?;
+        }
+
+        let parameter = parser
+            .lexer
+            .expect(TokenKind::Identifier, "expected a parameter name")?;
+
+        let parameter = match parameter.value {
+            TokenValue::Identifier(parameter) => parameter,
+            _ => unreachable!(),
+        };
+
+        parser.lexer.expect(TokenKind::Tilde, "expected a tilde")?;
+
+        let explicit_type = typing::parse(parser, BindingPower::None)?;
+
+        parameters.push(ParameterDeclaration {
+            name: parameter,
+            explicit_type,
+        });
+    }
+
+    parser
+        .lexer
+        .expect(TokenKind::ParenClose, "expected a close parenthesis")?;
+
+    let explicit_return_type = match parser.lexer.peek_expect(TokenKind::Tilde) {
+        None => None,
+        Some(_) => {
+            parser.lexer.next();
+            Some(typing::parse(parser, BindingPower::None)?)
+        }
+    };
+
+    Ok(FunctionHeader {
+        name,
+        parameters,
+        explicit_return_type,
     })
 }
diff --git a/src/parser/typing.rs b/src/parser/typing.rs
index 7c44fa9..a49088b 100644
--- a/src/parser/typing.rs
+++ b/src/parser/typing.rs
@@ -1,4 +1,8 @@
-use super::{ast::Type, lookup::BindingPower, Parser};
+use super::{
+    ast::{Spannable, Type, TypeValue},
+    lookup::BindingPower,
+    Parser,
+};
 use crate::lexer::{TokenKind, TokenValue};
 use miette::Result;
 
@@ -61,81 +65,90 @@ pub fn parse<'de>(parser: &mut Parser<'de>, binding_power: BindingPower) -> Resu
 }
 
 pub fn unit<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
-    parser
+    let open = parser
         .lexer
         .expect(TokenKind::ParenOpen, "expected an opening parenthesis")?;
 
-    parser
+    let close = parser
         .lexer
         .expect(TokenKind::ParenClose, "expected a closing parenthesis")?;
 
-    Ok(Type::Unit)
+    Ok(Type::at_multiple(
+        vec![open.span, close.span],
+        TypeValue::Unit,
+    ))
 }
 
 pub fn boolean<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::BooleanType, "expected a boolean type")?;
 
-    Ok(Type::Boolean)
+    Ok(Type::at(token.span, TypeValue::Boolean))
 }
 
 pub fn integer<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::IntegerType, "expected an integer type")?;
 
-    Ok(Type::Integer)
+    Ok(Type::at(token.span, TypeValue::Integer))
 }
 
 pub fn decimal<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::DecimalType, "expected a decimal type")?;
 
-    Ok(Type::Decimal)
+    Ok(Type::at(token.span, TypeValue::Decimal))
 }
 
 pub fn string<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::StringType, "expected a string type")?;
 
-    Ok(Type::String)
+    Ok(Type::at(token.span, TypeValue::String))
 }
 
 pub fn character<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
-    parser
+    let token = parser
         .lexer
         .expect(TokenKind::CharacterType, "expected a character type")?;
 
-    Ok(Type::Character)
+    Ok(Type::at(token.span, TypeValue::Character))
 }
 
 pub fn collection<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
-    parser
+    let open = parser
         .lexer
         .expect(TokenKind::SquareOpen, "expected an opening bracket")?;
     let element = parse(parser, BindingPower::None)?;
-    parser
+    let close = parser
         .lexer
         .expect(TokenKind::SquareClose, "expected a closing bracket")?;
 
-    Ok(Type::Collection(Box::new(element)))
+    Ok(Type::at_multiple(
+        vec![open.span, element.span, close.span],
+        TypeValue::Collection(Box::new(element)),
+    ))
 }
 
 pub fn set<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
-    parser
+    let open = parser
         .lexer
         .expect(TokenKind::CurlyOpen, "expected an opening curly brace")?;
 
     let element = parse(parser, BindingPower::None)?;
 
-    parser
+    let close = parser
         .lexer
         .expect(TokenKind::CurlyClose, "expected a closing curly brace")?;
 
-    Ok(Type::Set(Box::new(element)))
+    Ok(Type::at_multiple(
+        vec![open.span, element.span, close.span],
+        TypeValue::Set(Box::new(element)),
+    ))
 }
 
 pub fn identifier<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
@@ -143,10 +156,10 @@ pub fn identifier<'de>(parser: &mut Parser<'de>) -> Result<Type<'de>> {
         .lexer
         .expect(TokenKind::Identifier, "expected an identifier")?;
 
-    let identifier = match token.value {
+    let name = match token.value {
         TokenValue::Identifier(identifier) => identifier,
         _ => unreachable!(),
     };
 
-    Ok(Type::Symbol(identifier))
+    Ok(Type::at(token.span, TypeValue::Symbol(name)))
 }
diff --git a/src/passer/mod.rs b/src/passer/mod.rs
index 5626037..2fe59fd 100644
--- a/src/passer/mod.rs
+++ b/src/passer/mod.rs
@@ -1,5 +1,7 @@
+use std::collections::HashSet;
+
 use crate::parser::ast::Symbol;
-use miette::{Report, Result};
+use miette::{Report, Result, SourceSpan};
 
 pub mod typing;
 
@@ -7,7 +9,17 @@ pub trait Passer {
     fn pass(ast: &Symbol<'_>) -> Result<PasserResult>;
 }
 
+#[derive(Default)]
 pub struct PasserResult {
     pub non_critical: Vec<Report>,
     pub critical: Vec<Report>,
 }
+
+impl PasserResult {
+    pub fn combine(mut self, other: PasserResult) -> Self {
+        self.non_critical.extend(other.non_critical);
+        self.critical.extend(other.critical);
+
+        self
+    }
+}
diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
index ec94ec7..dd698d6 100644
--- a/src/passer/typing/mod.rs
+++ b/src/passer/typing/mod.rs
@@ -1,6 +1,10 @@
+use core::net;
+
 use super::{Passer, PasserResult};
 use crate::parser::{
-    ast::{Expression, ExpressionValue, Spannable, Statement, StatementValue, Symbol, Type, TypeValue},
+    ast::{
+        Expression, ExpressionValue, Spannable, Statement, StatementValue, Symbol, Type, TypeValue,
+    },
     expression,
 };
 use miette::{Error, LabeledSpan, Report, Result};
@@ -9,56 +13,202 @@ pub struct TypingPasser;
 
 impl Passer for TypingPasser {
     fn pass(ast: &Symbol<'_>) -> Result<PasserResult> {
-       todo!()
+        fn check_expression(expression: &Expression<'_>) -> Result<PasserResult> {
+            let mut critical = vec![];
+
+            let types = expression.possible_types();
+
+            // Get only distinct types, by comparing the `TypeValue` enum
+            let types = types.into_iter().fold(vec![], |mut acc, ty| {
+                if !acc.iter().any(|t: &Type<'_>| t.value == ty.value) {
+                    acc.push(ty);
+                }
+                acc
+            });
+
+            if types.is_empty() || types.len() == 1 {
+                return Ok(PasserResult::default());
+            }
+
+            let labels = types
+                .iter()
+                .map(|ty| LabeledSpan::at(ty.span, format!("{}", ty)))
+                .collect::<Vec<_>>();
+
+            critical.push(miette::miette! {
+                labels = labels,
+                help = "expression has multiple possible types",
+                "{:?} has multiple possible types", expression.value
+            });
+
+            Ok(PasserResult {
+                critical,
+                non_critical: vec![],
+            })
+        }
+
+        fn check_statement(statement: &Statement<'_>) -> Result<PasserResult> {
+            let mut critical = vec![];
+
+            let types = statement.possible_types();
+
+            if types.is_empty() || types.len() == 1 {
+                return Ok(PasserResult::default());
+            }
+
+            let labels = types
+                .iter()
+                .map(|ty| LabeledSpan::at(ty.span, format!("{}", ty)))
+                .collect::<Vec<_>>();
+
+            critical.push(miette::miette! {
+                labels = labels,
+                help = "statement has multiple possible types",
+                "{:?} has multiple possible types", statement.value
+            });
+
+            Ok(PasserResult {
+                critical,
+                non_critical: vec![],
+            })
+        }
+
+        walk(ast, check_statement, check_expression)
     }
 }
 
+pub fn walk<'de>(
+    symbol: &Symbol<'de>,
+    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
+    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
+) -> Result<PasserResult> {
+    match symbol {
+        Symbol::Statement(statement) => walk_statement(statement, statement_fn, expression_fn),
+        Symbol::Expression(expression) => walk_expression(expression, statement_fn, expression_fn),
+    }
+}
 
-pub fn walk_statement<'de>(statement: &Statement<'de>, statement_fn: fn(&Statement<'de>), expression_fn: fn(&Expression<'de>)) {
-    match statement {
-        Statement::Block(statements) => statements.iter().for_each(|statement| {
-            walk_statement(statement, statement_fn, expression_fn);
-        }),
-        Statement::Expression(expression) => walk_expression(statement_fn, expression_fn),
-        Statement::Assignment { name, value } => walk_expression(expression, expression_fn),
-        Statement::Struct { name, fields } => {},
-        Statement::Enum { name, variants } => {},
-        Statement::Function {
-            header,
-            body,
-            explicit_return_type,
-        } => ,
-        Statement::Trait { name, functions } => todo!(),
-        Statement::Return(expression) => todo!(),
-        Statement::Conditional {
+pub fn walk_statement<'de>(
+    statement: &Statement<'de>,
+    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
+    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
+) -> Result<PasserResult> {
+    let mut result = statement_fn(statement)?;
+
+    match &statement.value {
+        StatementValue::Block(statements) => {
+            for statement in statements {
+                result = result.combine(walk_statement(statement, statement_fn, expression_fn)?);
+            }
+        }
+        StatementValue::Expression(expression) => {
+            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
+        }
+        StatementValue::Assignment { name, value } => {
+            result = result.combine(walk_expression(value, statement_fn, expression_fn)?);
+        }
+        StatementValue::Struct { name, fields } => {}
+        StatementValue::Enum { name, variants } => {}
+        StatementValue::Function { header, body } => {
+            result = result.combine(walk_expression(body, statement_fn, expression_fn)?);
+        }
+        StatementValue::Trait { name, functions } => {}
+        StatementValue::Return(expression) => {
+            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
+        }
+        StatementValue::Conditional {
             condition,
             truthy,
             falsy,
-        } => todo!(),
+        } => {
+            result = result.combine(walk_expression(condition, statement_fn, expression_fn)?);
+            result = result.combine(walk_statement(truthy, statement_fn, expression_fn)?);
+            if let Some(falsy) = falsy {
+                result = result.combine(walk_statement(falsy, statement_fn, expression_fn)?);
+            }
+        }
     }
+
+    Ok(result)
 }
 
-pub fn walk_expression<'de, T>(expression: Expression<'de>, statement_fn: fn(&Statement<'de>, expression_fn: fn(&Expression<'de>))) {
-    todo!()
+pub fn walk_expression<'de>(
+    expression: &Expression<'de>,
+    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
+    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
+) -> Result<PasserResult> {
+    let mut result = expression_fn(expression)?;
+
+    match &expression.value {
+        ExpressionValue::Binary {
+            operator,
+            left,
+            right,
+        } => {
+            result = result.combine(walk_expression(left, statement_fn, expression_fn)?);
+            result = result.combine(walk_expression(right, statement_fn, expression_fn)?);
+        }
+        ExpressionValue::Unary { operator, operand } => {
+            result = result.combine(walk_expression(operand, statement_fn, expression_fn)?);
+        }
+        ExpressionValue::Group(expression) => {
+            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
+        }
+        ExpressionValue::Block {
+            statements,
+            return_value,
+        } => {
+            for statement in statements {
+                result = result.combine(walk_statement(statement, statement_fn, expression_fn)?);
+            }
+            result = result.combine(walk_expression(return_value, statement_fn, expression_fn)?);
+        }
+        ExpressionValue::Conditional {
+            condition,
+            truthy,
+            falsy,
+        } => {
+            result = result.combine(walk_expression(condition, statement_fn, expression_fn)?);
+            result = result.combine(walk_expression(truthy, statement_fn, expression_fn)?);
+            result = result.combine(walk_expression(falsy, statement_fn, expression_fn)?);
+        }
+        ExpressionValue::Call { callee, arguments } => {
+            result = result.combine(walk_expression(callee, statement_fn, expression_fn)?);
+            for argument in arguments {
+                result = result.combine(walk_expression(argument, statement_fn, expression_fn)?);
+            }
+        }
+        ExpressionValue::Primitive(_) => {}
+    }
+
+    Ok(result)
 }
 
-pub trait Typing {
-    fn possible_types(&self) -> Vec<(Type, miette::SourceSpan)>;
+pub trait Typing<'de> {
+    fn possible_types(&self) -> Vec<Type<'de>>;
 }
 
-impl Typing for Expression<'_> {
-    fn possible_types(&self) -> Vec<(Type, miette::SourceSpan)> {
+impl<'de> Typing<'de> for Expression<'de> {
+    fn possible_types(&self) -> Vec<Type<'de>> {
         match &self.value {
             ExpressionValue::Primitive(primitive) => vec![match primitive {
-                crate::parser::ast::Primitive::Integer(_) => Type::at(self.span, TypeValue::Integer),
-                crate::parser::ast::Primitive::Decimal(_) => (Type::Decimal, self.span),
-                crate::parser::ast::Primitive::String(_) => (Type::String, self.span),
+                crate::parser::ast::Primitive::Integer(_) => {
+                    Type::at(self.span, TypeValue::Integer)
+                }
+                crate::parser::ast::Primitive::Decimal(_) => {
+                    Type::at(self.span, TypeValue::Decimal)
+                }
+                crate::parser::ast::Primitive::String(_) => Type::at(self.span, TypeValue::String),
                 crate::parser::ast::Primitive::Identifier(value) => {
-                    (Type::Symbol(value.clone()), self.span)
+                    Type::at(self.span, TypeValue::Symbol(value.clone()))
+                }
+                crate::parser::ast::Primitive::Character(_) => {
+                    Type::at(self.span, TypeValue::Character)
                 }
-                crate::parser::ast::Primitive::Character(_) => (Type::Character, self.span),
-                crate::parser::ast::Primitive::Boolean(_) => (Type::Boolean, self.span),
-                crate::parser::ast::Primitive::Unit => (Type::Unit, self.span),
+                crate::parser::ast::Primitive::Boolean(_) => {
+                    Type::at(self.span, TypeValue::Boolean)
+                }
+                crate::parser::ast::Primitive::Unit => Type::at(self.span, TypeValue::Unit),
             }],
             ExpressionValue::Binary {
                 operator: _,
@@ -95,34 +245,35 @@ impl Typing for Expression<'_> {
     }
 }
 
-impl Typing for Statement<'_> {
-    fn possible_types(&self) -> Vec<(Type, miette::SourceSpan)> {
+impl<'de> Typing<'de> for Statement<'de> {
+    fn possible_types(&self) -> Vec<Type<'de>> {
         match &self.value {
             StatementValue::Block(statements) => vec![],
             StatementValue::Expression(expression) => expression.possible_types(),
             StatementValue::Assignment { name: _, value } => value.possible_types(),
-            StatementValue::Struct { name, fields } => vec![(Type::Symbol(name.clone()), self.span)],
-            StatementValue::Enum { name, variants } => vec![(Type::Symbol(name.clone()), self.span)],
-            StatementValue::Function {
-                header: _,
-                body,
-               
-            } => {
+            StatementValue::Struct { name, fields } => {
+                vec![Type::at(self.span, TypeValue::Symbol(name.clone()))]
+            }
+            StatementValue::Enum { name, variants } => {
+                vec![Type::at(self.span, TypeValue::Symbol(name.clone()))]
+            }
+            StatementValue::Function { header, body } => {
                 let mut types = body.possible_types();
-                if let Some(explicit_return_type) = explicit_return_type {
-                    types.push((explicit_return_type,));
+                if let Some(explicit_return_type) = &header.explicit_return_type {
+                    types.push(explicit_return_type.clone());
                 }
                 types
             }
-            StatementValue::Trait { name, functions } => vec![(Type::Symbol(name.clone()), self.span)],
+            StatementValue::Trait { name, functions } => {
+                vec![Type::at(self.span, TypeValue::Symbol(name.clone()))]
+            }
             StatementValue::Return(expression) => expression.possible_types(),
             StatementValue::Conditional {
                 condition,
                 truthy,
                 falsy,
             } => {
-                let mut types = condition.possible_types();
-                types.extend(truthy.possible_types());
+                let mut types = truthy.possible_types();
                 if let Some(falsy) = falsy {
                     types.extend(falsy.possible_types());
                 }

From f50bb5a2f9f0db5fa342056d2de9393123e6317e Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Sat, 2 Nov 2024 16:12:00 +0100
Subject: [PATCH 33/43] =?UTF-8?q?=F0=9F=90=9B=20Fix=20duplicate=20typing?=
 =?UTF-8?q?=20error=20messages?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: patch
---
 src/main.rs              |  2 +-
 src/passer/typing/mod.rs | 20 ++++++++++++++------
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 3959ce4..33c0962 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,7 +12,7 @@ pub mod parser;
 pub mod passer;
 
 const INPUT: &str = "
-let a = 1 + 1.1 - true * 'c' / \"hello\"
+let a = 1 if true else 2
 ";
 
 fn main() {
diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
index dd698d6..63f50ca 100644
--- a/src/passer/typing/mod.rs
+++ b/src/passer/typing/mod.rs
@@ -35,11 +35,11 @@ impl Passer for TypingPasser {
                 .map(|ty| LabeledSpan::at(ty.span, format!("{}", ty)))
                 .collect::<Vec<_>>();
 
-            critical.push(miette::miette! {
-                labels = labels,
-                help = "expression has multiple possible types",
-                "{:?} has multiple possible types", expression.value
-            });
+            // critical.push(miette::miette! {
+            //     labels = labels,
+            //     help = "expression has multiple possible types",
+            //     "{:?} has multiple possible types", expression.value
+            // });
 
             Ok(PasserResult {
                 critical,
@@ -50,7 +50,15 @@ impl Passer for TypingPasser {
         fn check_statement(statement: &Statement<'_>) -> Result<PasserResult> {
             let mut critical = vec![];
 
-            let types = statement.possible_types();
+            let types = statement
+                .possible_types()
+                .into_iter()
+                .fold(vec![], |mut acc, ty| {
+                    if !acc.iter().any(|t: &Type<'_>| t.value == ty.value) {
+                        acc.push(ty);
+                    }
+                    acc
+                });
 
             if types.is_empty() || types.len() == 1 {
                 return Ok(PasserResult::default());

From c46b92cb93f8ef2a19138cab206126c23f023e06 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Sat, 2 Nov 2024 16:24:41 +0100
Subject: [PATCH 34/43] =?UTF-8?q?=F0=9F=90=9B=20Fix=20unit=20types=20not?=
 =?UTF-8?q?=20having=20a=20correct=20span?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: patch
---
 src/main.rs              |  4 +++-
 src/parser/ast.rs        |  2 +-
 src/parser/lookup.rs     | 13 +++++++++----
 src/passer/typing/mod.rs | 24 +++++++++++-------------
 4 files changed, 24 insertions(+), 19 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 33c0962..3c1d61a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,7 +12,9 @@ pub mod parser;
 pub mod passer;
 
 const INPUT: &str = "
-let a = 1 if true else 2
+fn test() {
+    let a = 12 + {true + false;};
+}
 ";
 
 fn main() {
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index d32e4b3..b0b10d9 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -161,7 +161,7 @@ pub enum TypeValue<'de> {
 impl Display for Type<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self.value {
-            TypeValue::Unit => write!(f, "an unit"),
+            TypeValue::Unit => write!(f, "nothing"),
             TypeValue::Boolean => write!(f, "a boolean"),
             TypeValue::Integer => write!(f, "an integer"),
             TypeValue::Decimal => write!(f, "a decimal"),
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index a9d7cea..cae018c 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -3,7 +3,7 @@ use super::{
     expression, statement, typing, Parser,
 };
 use crate::lexer::{TokenKind, TokenValue};
-use miette::{Result, SourceSpan};
+use miette::{Context, Result, SourceSpan};
 use std::collections::HashMap;
 
 #[derive(Debug, Clone, PartialEq, PartialOrd)]
@@ -282,7 +282,8 @@ fn block<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
             break;
         }
 
-        let statement = crate::parser::statement::parse(parser, true)?;
+        let statement =
+            crate::parser::statement::parse(parser, true).wrap_err("while parsing block")?;
         statements.push(statement);
     }
 
@@ -293,13 +294,17 @@ fn block<'de>(parser: &mut Parser<'de>) -> Result<Expression<'de>> {
                 _ => unreachable!(),
             },
             _ => Expression::at(
-                SourceSpan::new(0.into(), 0),
+                statements
+                    .last()
+                    .map_or(SourceSpan::new(0.into(), 0), |s| s.span),
                 ExpressionValue::Primitive(Primitive::Unit),
             ),
         }
     } else {
         Expression::at(
-            SourceSpan::new(0.into(), 0),
+            statements
+                .last()
+                .map_or(SourceSpan::new(0.into(), 0), |s| s.span),
             ExpressionValue::Primitive(Primitive::Unit),
         )
     };
diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
index 63f50ca..292cfd5 100644
--- a/src/passer/typing/mod.rs
+++ b/src/passer/typing/mod.rs
@@ -18,15 +18,14 @@ impl Passer for TypingPasser {
 
             let types = expression.possible_types();
 
-            // Get only distinct types, by comparing the `TypeValue` enum
-            let types = types.into_iter().fold(vec![], |mut acc, ty| {
+            let distinct_types = types.clone().into_iter().fold(vec![], |mut acc, ty| {
                 if !acc.iter().any(|t: &Type<'_>| t.value == ty.value) {
                     acc.push(ty);
                 }
                 acc
             });
 
-            if types.is_empty() || types.len() == 1 {
+            if distinct_types.is_empty() || distinct_types.len() == 1 {
                 return Ok(PasserResult::default());
             }
 
@@ -50,17 +49,16 @@ impl Passer for TypingPasser {
         fn check_statement(statement: &Statement<'_>) -> Result<PasserResult> {
             let mut critical = vec![];
 
-            let types = statement
-                .possible_types()
-                .into_iter()
-                .fold(vec![], |mut acc, ty| {
-                    if !acc.iter().any(|t: &Type<'_>| t.value == ty.value) {
-                        acc.push(ty);
-                    }
-                    acc
-                });
+            let types = statement.possible_types();
 
-            if types.is_empty() || types.len() == 1 {
+            let distinct_types = types.clone().into_iter().fold(vec![], |mut acc, ty| {
+                if !acc.iter().any(|t: &Type<'_>| t.value == ty.value) {
+                    acc.push(ty);
+                }
+                acc
+            });
+
+            if distinct_types.is_empty() || distinct_types.len() == 1 {
                 return Ok(PasserResult::default());
             }
 

From e8a8359d53596b56d4c5b303a2e1fc92f9dbbee1 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Sat, 2 Nov 2024 16:55:39 +0100
Subject: [PATCH 35/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs                  |   5 +-
 src/parser/ast.rs            | 102 +++++++++++++++++++++++++++++++++++
 src/parser/expression/mod.rs |   6 +--
 src/parser/statement.rs      |   6 +--
 src/passer/mod.rs            |   2 +-
 src/passer/typing/mod.rs     |  33 +-----------
 6 files changed, 114 insertions(+), 40 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 3c1d61a..da52895 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,8 +12,9 @@ pub mod parser;
 pub mod passer;
 
 const INPUT: &str = "
-fn test() {
-    let a = 12 + {true + false;};
+fn main() {
+    let string = \"Hello, world!\";
+    println(argument);
 }
 ";
 
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index b0b10d9..04ec6fb 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -46,6 +46,108 @@ pub enum StatementValue<'de> {
     },
 }
 
+impl Display for StatementValue<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            StatementValue::Block(vec) => write!(f, "a block of {} statements", vec.len()),
+            StatementValue::Expression(expression) => write!(f, "{}", expression),
+            StatementValue::Assignment { name, value } => {
+                write!(f, "`{}` assignment with {}", name, value)
+            }
+            StatementValue::Struct { name, fields } => write!(f, "`{}` struct", name),
+            StatementValue::Enum { name, variants } => write!(f, "`{}` enum", name),
+            StatementValue::Function { header, body } => write!(f, "`{}` function", header.name),
+            StatementValue::Trait { name, functions } => write!(f, "`{}` trait", name),
+            StatementValue::Return(expression) => write!(f, "returning {}", expression),
+            StatementValue::Conditional {
+                condition,
+                truthy,
+                falsy,
+            } => write!(f, "conditional statement"),
+        }
+    }
+}
+
+impl Display for Statement<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.value)
+    }
+}
+
+impl Display for ExpressionValue<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ExpressionValue::Primitive(primitive) => write!(f, "{}", primitive),
+            ExpressionValue::Binary {
+                operator,
+                left,
+                right,
+            } => write!(f, "{} expression", operator),
+            ExpressionValue::Unary { operator, operand } => write!(f, "{} expression", operator),
+            ExpressionValue::Group(expression) => write!(f, "grouped expression"),
+            ExpressionValue::Block {
+                statements,
+                return_value,
+            } => write!(f, "block expression"),
+            ExpressionValue::Conditional {
+                condition,
+                truthy,
+                falsy,
+            } => write!(f, "conditional expression"),
+            ExpressionValue::Call { callee, arguments } => write!(f, "calling {}", callee.value),
+        }
+    }
+}
+
+impl Display for Primitive<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Primitive::Integer(value) => write!(f, "{}", value),
+            Primitive::Decimal(value) => write!(f, "{}", value),
+            Primitive::String(value) => write!(f, "{}", value),
+            Primitive::Identifier(value) => write!(f, "{}", value),
+            Primitive::Character(value) => write!(f, "{}", value),
+            Primitive::Boolean(value) => write!(f, "{}", value),
+            Primitive::Unit => write!(f, "nothing"),
+        }
+    }
+}
+
+impl Display for Expression<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.value)
+    }
+}
+
+impl Display for BinaryOperator {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            BinaryOperator::Add => write!(f, "addition"),
+            BinaryOperator::Subtract => write!(f, "subtraction"),
+            BinaryOperator::Multiply => write!(f, "multiplication"),
+            BinaryOperator::Divide => write!(f, "division"),
+            BinaryOperator::Modulo => write!(f, "modulo"),
+            BinaryOperator::Equality => write!(f, "equality"),
+            BinaryOperator::Inequality => write!(f, "inequality"),
+            BinaryOperator::LessThan => write!(f, "less than"),
+            BinaryOperator::LessThanOrEqual => write!(f, "less than or equal"),
+            BinaryOperator::GreaterThan => write!(f, "greater than"),
+            BinaryOperator::GreaterThanOrEqual => write!(f, "greater than or equal"),
+            BinaryOperator::And => write!(f, "and"),
+            BinaryOperator::Or => write!(f, "or"),
+        }
+    }
+}
+
+impl Display for UnaryOperator {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            UnaryOperator::Negate => write!(f, "negation"),
+            UnaryOperator::Negative => write!(f, "negative"),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct Expression<'de> {
     pub value: ExpressionValue<'de>,
diff --git a/src/parser/expression/mod.rs b/src/parser/expression/mod.rs
index 45f7aa7..9bb74e1 100644
--- a/src/parser/expression/mod.rs
+++ b/src/parser/expression/mod.rs
@@ -93,12 +93,12 @@ pub fn call<'de>(
         arguments.push(argument);
     }
 
-    parser
+    let close = parser
         .lexer
         .expect(TokenKind::ParenClose, "expected a closing parenthesis")?;
 
-    Ok(Expression::at(
-        lhs.span,
+    Ok(Expression::at_multiple(
+        vec![lhs.span, close.span],
         ExpressionValue::Call {
             callee: Box::new(lhs.clone()),
             arguments,
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index cb0f2d9..9c526ea 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -244,14 +244,14 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
 }
 
 pub fn return_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
-    let token = parser
+    parser
         .lexer
         .expect(TokenKind::Return, "expected a return keyword")?;
 
     let expression = expression::parse(parser, BindingPower::None)?;
 
-    Ok(Statement::at_multiple(
-        vec![token.span, expression.span],
+    Ok(Statement::at(
+        expression.span,
         StatementValue::Return(expression),
     ))
 }
diff --git a/src/passer/mod.rs b/src/passer/mod.rs
index 2fe59fd..94b2fdb 100644
--- a/src/passer/mod.rs
+++ b/src/passer/mod.rs
@@ -9,7 +9,7 @@ pub trait Passer {
     fn pass(ast: &Symbol<'_>) -> Result<PasserResult>;
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct PasserResult {
     pub non_critical: Vec<Report>,
     pub critical: Vec<Report>,
diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
index 292cfd5..c0395fc 100644
--- a/src/passer/typing/mod.rs
+++ b/src/passer/typing/mod.rs
@@ -14,36 +14,7 @@ pub struct TypingPasser;
 impl Passer for TypingPasser {
     fn pass(ast: &Symbol<'_>) -> Result<PasserResult> {
         fn check_expression(expression: &Expression<'_>) -> Result<PasserResult> {
-            let mut critical = vec![];
-
-            let types = expression.possible_types();
-
-            let distinct_types = types.clone().into_iter().fold(vec![], |mut acc, ty| {
-                if !acc.iter().any(|t: &Type<'_>| t.value == ty.value) {
-                    acc.push(ty);
-                }
-                acc
-            });
-
-            if distinct_types.is_empty() || distinct_types.len() == 1 {
-                return Ok(PasserResult::default());
-            }
-
-            let labels = types
-                .iter()
-                .map(|ty| LabeledSpan::at(ty.span, format!("{}", ty)))
-                .collect::<Vec<_>>();
-
-            // critical.push(miette::miette! {
-            //     labels = labels,
-            //     help = "expression has multiple possible types",
-            //     "{:?} has multiple possible types", expression.value
-            // });
-
-            Ok(PasserResult {
-                critical,
-                non_critical: vec![],
-            })
+            Ok(PasserResult::default())
         }
 
         fn check_statement(statement: &Statement<'_>) -> Result<PasserResult> {
@@ -70,7 +41,7 @@ impl Passer for TypingPasser {
             critical.push(miette::miette! {
                 labels = labels,
                 help = "statement has multiple possible types",
-                "{:?} has multiple possible types", statement.value
+                "{} has multiple possible types", statement.value
             });
 
             Ok(PasserResult {

From 1c870a92482c2e5c5423f47c26474937ab7d69fa Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Sat, 2 Nov 2024 16:56:12 +0100
Subject: [PATCH 36/43] =?UTF-8?q?=E2=9E=95=20Add=20`inkwell`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: patch
---
 Cargo.lock | 33 ++++++++++++++++++++++++++++++++-
 Cargo.toml |  1 +
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/Cargo.lock b/Cargo.lock
index 05008ee..2b4b607 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -122,6 +122,12 @@ version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
 
+[[package]]
+name = "either"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+
 [[package]]
 name = "equivalent"
 version = "1.0.1"
@@ -176,6 +182,30 @@ dependencies = [
  "hashbrown",
 ]
 
+[[package]]
+name = "inkwell"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40fb405537710d51f6bdbc8471365ddd4cd6d3a3c3ad6e0c8291691031ba94b2"
+dependencies = [
+ "either",
+ "inkwell_internals",
+ "libc",
+ "once_cell",
+ "thiserror",
+]
+
+[[package]]
+name = "inkwell_internals"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd28cfd4cfba665d47d31c08a6ba637eed16770abca2eccbbc3ca831fef1e44"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "is_ci"
 version = "1.2.0"
@@ -484,6 +514,7 @@ checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
 name = "som"
 version = "0.1.0"
 dependencies = [
+ "inkwell",
  "miette",
  "owo-colors",
  "pretty_assertions",
@@ -650,7 +681,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 793738d..cefdfd0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,6 +7,7 @@ authors = ["Somfic"]
 description = "The 'som' programming language"
 
 [dependencies]
+inkwell = "0.5.0"
 miette = { version = "7.2.0", features = ["fancy", "syntect-highlighter"] }
 owo-colors = "4.1.0"
 pretty_assertions = "1.4.1"

From 1b00a59432bb9a601652922daa1005024b113128 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Sat, 2 Nov 2024 20:24:37 +0100
Subject: [PATCH 37/43] =?UTF-8?q?=F0=9F=9A=A7=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 Cargo.lock               |  55 ++++++++++++++++++++
 Cargo.toml               |   2 +-
 readme.md                |  14 +++++
 src/passer/mod.rs        | 107 +++++++++++++++++++++++++++++++++++++++
 src/passer/typing/mod.rs | 107 ---------------------------------------
 5 files changed, 177 insertions(+), 108 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2b4b607..756990b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -191,6 +191,7 @@ dependencies = [
  "either",
  "inkwell_internals",
  "libc",
+ "llvm-sys",
  "once_cell",
  "thiserror",
 ]
@@ -218,6 +219,12 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
 [[package]]
 name = "libc"
 version = "0.2.161"
@@ -236,6 +243,19 @@ version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
 
+[[package]]
+name = "llvm-sys"
+version = "130.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c20142c91fc4bde4036edbaf0d112f79667831d612efbaabe862ab9748fdd67c"
+dependencies = [
+ "cc",
+ "lazy_static",
+ "libc",
+ "regex",
+ "semver",
+]
+
 [[package]]
 name = "memchr"
 version = "2.7.2"
@@ -341,6 +361,17 @@ version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fb37767f6569cd834a413442455e0f066d0d522de8630436e2a1761d9726ba56"
 
+[[package]]
+name = "pest"
+version = "2.7.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879952a81a83930934cbf1786752d6dedc3b1f29e8f8fb2ad1d0a36f377cf442"
+dependencies = [
+ "memchr",
+ "thiserror",
+ "ucd-trie",
+]
+
 [[package]]
 name = "pkg-config"
 version = "0.3.31"
@@ -466,6 +497,24 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "semver"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
+dependencies = [
+ "semver-parser",
+]
+
+[[package]]
+name = "semver-parser"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7"
+dependencies = [
+ "pest",
+]
+
 [[package]]
 name = "serde"
 version = "1.0.210"
@@ -647,6 +696,12 @@ dependencies = [
  "time-core",
 ]
 
+[[package]]
+name = "ucd-trie"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.13"
diff --git a/Cargo.toml b/Cargo.toml
index cefdfd0..98d4280 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,7 @@ authors = ["Somfic"]
 description = "The 'som' programming language"
 
 [dependencies]
-inkwell = "0.5.0"
+inkwell = { version = "0.5.0", features = ["llvm13-0"] }
 miette = { version = "7.2.0", features = ["fancy", "syntect-highlighter"] }
 owo-colors = "4.1.0"
 pretty_assertions = "1.4.1"
diff --git a/readme.md b/readme.md
index e63be55..345ce50 100644
--- a/readme.md
+++ b/readme.md
@@ -49,3 +49,17 @@ code Purrer for Cat:
   };
 
 ```
+
+
+```
+install cmake
+install strawberryperl
+
+winget install Ninja-build.Ninja
+
+
+cargo install llvmenv
+llvmenv init
+llvmenv entries
+llvmenv build-entry 10.0.0
+```
diff --git a/src/passer/mod.rs b/src/passer/mod.rs
index 94b2fdb..4c787fa 100644
--- a/src/passer/mod.rs
+++ b/src/passer/mod.rs
@@ -23,3 +23,110 @@ impl PasserResult {
         self
     }
 }
+
+pub fn walk<'de>(
+    symbol: &Symbol<'de>,
+    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
+    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
+) -> Result<PasserResult> {
+    match symbol {
+        Symbol::Statement(statement) => walk_statement(statement, statement_fn, expression_fn),
+        Symbol::Expression(expression) => walk_expression(expression, statement_fn, expression_fn),
+    }
+}
+
+fn walk_statement<'de>(
+    statement: &Statement<'de>,
+    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
+    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
+) -> Result<PasserResult> {
+    let mut result = statement_fn(statement)?;
+
+    match &statement.value {
+        StatementValue::Block(statements) => {
+            for statement in statements {
+                result = result.combine(walk_statement(statement, statement_fn, expression_fn)?);
+            }
+        }
+        StatementValue::Expression(expression) => {
+            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
+        }
+        StatementValue::Assignment { name, value } => {
+            result = result.combine(walk_expression(value, statement_fn, expression_fn)?);
+        }
+        StatementValue::Struct { name, fields } => {}
+        StatementValue::Enum { name, variants } => {}
+        StatementValue::Function { header, body } => {
+            result = result.combine(walk_expression(body, statement_fn, expression_fn)?);
+        }
+        StatementValue::Trait { name, functions } => {}
+        StatementValue::Return(expression) => {
+            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
+        }
+        StatementValue::Conditional {
+            condition,
+            truthy,
+            falsy,
+        } => {
+            result = result.combine(walk_expression(condition, statement_fn, expression_fn)?);
+            result = result.combine(walk_statement(truthy, statement_fn, expression_fn)?);
+            if let Some(falsy) = falsy {
+                result = result.combine(walk_statement(falsy, statement_fn, expression_fn)?);
+            }
+        }
+    }
+
+    Ok(result)
+}
+
+fn walk_expression<'de>(
+    expression: &Expression<'de>,
+    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
+    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
+) -> Result<PasserResult> {
+    let mut result = expression_fn(expression)?;
+
+    match &expression.value {
+        ExpressionValue::Binary {
+            operator,
+            left,
+            right,
+        } => {
+            result = result.combine(walk_expression(left, statement_fn, expression_fn)?);
+            result = result.combine(walk_expression(right, statement_fn, expression_fn)?);
+        }
+        ExpressionValue::Unary { operator, operand } => {
+            result = result.combine(walk_expression(operand, statement_fn, expression_fn)?);
+        }
+        ExpressionValue::Group(expression) => {
+            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
+        }
+        ExpressionValue::Block {
+            statements,
+            return_value,
+        } => {
+            for statement in statements {
+                result = result.combine(walk_statement(statement, statement_fn, expression_fn)?);
+            }
+            result = result.combine(walk_expression(return_value, statement_fn, expression_fn)?);
+        }
+        ExpressionValue::Conditional {
+            condition,
+            truthy,
+            falsy,
+        } => {
+            result = result.combine(walk_expression(condition, statement_fn, expression_fn)?);
+            result = result.combine(walk_expression(truthy, statement_fn, expression_fn)?);
+            result = result.combine(walk_expression(falsy, statement_fn, expression_fn)?);
+        }
+        ExpressionValue::Call { callee, arguments } => {
+            result = result.combine(walk_expression(callee, statement_fn, expression_fn)?);
+            for argument in arguments {
+                result = result.combine(walk_expression(argument, statement_fn, expression_fn)?);
+            }
+        }
+        ExpressionValue::Primitive(_) => {}
+    }
+
+    Ok(result)
+}
diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
index c0395fc..14e79a2 100644
--- a/src/passer/typing/mod.rs
+++ b/src/passer/typing/mod.rs
@@ -54,113 +54,6 @@ impl Passer for TypingPasser {
     }
 }
 
-pub fn walk<'de>(
-    symbol: &Symbol<'de>,
-    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
-    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
-) -> Result<PasserResult> {
-    match symbol {
-        Symbol::Statement(statement) => walk_statement(statement, statement_fn, expression_fn),
-        Symbol::Expression(expression) => walk_expression(expression, statement_fn, expression_fn),
-    }
-}
-
-pub fn walk_statement<'de>(
-    statement: &Statement<'de>,
-    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
-    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
-) -> Result<PasserResult> {
-    let mut result = statement_fn(statement)?;
-
-    match &statement.value {
-        StatementValue::Block(statements) => {
-            for statement in statements {
-                result = result.combine(walk_statement(statement, statement_fn, expression_fn)?);
-            }
-        }
-        StatementValue::Expression(expression) => {
-            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
-        }
-        StatementValue::Assignment { name, value } => {
-            result = result.combine(walk_expression(value, statement_fn, expression_fn)?);
-        }
-        StatementValue::Struct { name, fields } => {}
-        StatementValue::Enum { name, variants } => {}
-        StatementValue::Function { header, body } => {
-            result = result.combine(walk_expression(body, statement_fn, expression_fn)?);
-        }
-        StatementValue::Trait { name, functions } => {}
-        StatementValue::Return(expression) => {
-            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
-        }
-        StatementValue::Conditional {
-            condition,
-            truthy,
-            falsy,
-        } => {
-            result = result.combine(walk_expression(condition, statement_fn, expression_fn)?);
-            result = result.combine(walk_statement(truthy, statement_fn, expression_fn)?);
-            if let Some(falsy) = falsy {
-                result = result.combine(walk_statement(falsy, statement_fn, expression_fn)?);
-            }
-        }
-    }
-
-    Ok(result)
-}
-
-pub fn walk_expression<'de>(
-    expression: &Expression<'de>,
-    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
-    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
-) -> Result<PasserResult> {
-    let mut result = expression_fn(expression)?;
-
-    match &expression.value {
-        ExpressionValue::Binary {
-            operator,
-            left,
-            right,
-        } => {
-            result = result.combine(walk_expression(left, statement_fn, expression_fn)?);
-            result = result.combine(walk_expression(right, statement_fn, expression_fn)?);
-        }
-        ExpressionValue::Unary { operator, operand } => {
-            result = result.combine(walk_expression(operand, statement_fn, expression_fn)?);
-        }
-        ExpressionValue::Group(expression) => {
-            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
-        }
-        ExpressionValue::Block {
-            statements,
-            return_value,
-        } => {
-            for statement in statements {
-                result = result.combine(walk_statement(statement, statement_fn, expression_fn)?);
-            }
-            result = result.combine(walk_expression(return_value, statement_fn, expression_fn)?);
-        }
-        ExpressionValue::Conditional {
-            condition,
-            truthy,
-            falsy,
-        } => {
-            result = result.combine(walk_expression(condition, statement_fn, expression_fn)?);
-            result = result.combine(walk_expression(truthy, statement_fn, expression_fn)?);
-            result = result.combine(walk_expression(falsy, statement_fn, expression_fn)?);
-        }
-        ExpressionValue::Call { callee, arguments } => {
-            result = result.combine(walk_expression(callee, statement_fn, expression_fn)?);
-            for argument in arguments {
-                result = result.combine(walk_expression(argument, statement_fn, expression_fn)?);
-            }
-        }
-        ExpressionValue::Primitive(_) => {}
-    }
-
-    Ok(result)
-}
-
 pub trait Typing<'de> {
     fn possible_types(&self) -> Vec<Type<'de>>;
 }

From 000d039d14465fdc223abb3bfadeb46987105af5 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Mon, 4 Nov 2024 00:23:29 +0100
Subject: [PATCH 38/43] =?UTF-8?q?=F0=9F=9A=A7=20(WIP):=20WIP?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 Cargo.lock               | 86 ----------------------------------------
 Cargo.toml               |  1 -
 src/main.rs              | 10 ++++-
 src/parser/ast.rs        | 32 +++++++++++++++
 src/passer/mod.rs        |  3 +-
 src/passer/typing/mod.rs | 12 ++++--
 src/passer/unused.rs     | 75 +++++++++++++++++++++++++++++++++++
 7 files changed, 126 insertions(+), 93 deletions(-)
 create mode 100644 src/passer/unused.rs

diff --git a/Cargo.lock b/Cargo.lock
index 756990b..8fa2740 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -122,12 +122,6 @@ version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
 
-[[package]]
-name = "either"
-version = "1.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
-
 [[package]]
 name = "equivalent"
 version = "1.0.1"
@@ -182,31 +176,6 @@ dependencies = [
  "hashbrown",
 ]
 
-[[package]]
-name = "inkwell"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40fb405537710d51f6bdbc8471365ddd4cd6d3a3c3ad6e0c8291691031ba94b2"
-dependencies = [
- "either",
- "inkwell_internals",
- "libc",
- "llvm-sys",
- "once_cell",
- "thiserror",
-]
-
-[[package]]
-name = "inkwell_internals"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd28cfd4cfba665d47d31c08a6ba637eed16770abca2eccbbc3ca831fef1e44"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "is_ci"
 version = "1.2.0"
@@ -219,12 +188,6 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
 [[package]]
 name = "libc"
 version = "0.2.161"
@@ -243,19 +206,6 @@ version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
 
-[[package]]
-name = "llvm-sys"
-version = "130.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20142c91fc4bde4036edbaf0d112f79667831d612efbaabe862ab9748fdd67c"
-dependencies = [
- "cc",
- "lazy_static",
- "libc",
- "regex",
- "semver",
-]
-
 [[package]]
 name = "memchr"
 version = "2.7.2"
@@ -361,17 +311,6 @@ version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fb37767f6569cd834a413442455e0f066d0d522de8630436e2a1761d9726ba56"
 
-[[package]]
-name = "pest"
-version = "2.7.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "879952a81a83930934cbf1786752d6dedc3b1f29e8f8fb2ad1d0a36f377cf442"
-dependencies = [
- "memchr",
- "thiserror",
- "ucd-trie",
-]
-
 [[package]]
 name = "pkg-config"
 version = "0.3.31"
@@ -497,24 +436,6 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "semver"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
-dependencies = [
- "semver-parser",
-]
-
-[[package]]
-name = "semver-parser"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7"
-dependencies = [
- "pest",
-]
-
 [[package]]
 name = "serde"
 version = "1.0.210"
@@ -563,7 +484,6 @@ checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
 name = "som"
 version = "0.1.0"
 dependencies = [
- "inkwell",
  "miette",
  "owo-colors",
  "pretty_assertions",
@@ -696,12 +616,6 @@ dependencies = [
  "time-core",
 ]
 
-[[package]]
-name = "ucd-trie"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.13"
diff --git a/Cargo.toml b/Cargo.toml
index 98d4280..793738d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,6 @@ authors = ["Somfic"]
 description = "The 'som' programming language"
 
 [dependencies]
-inkwell = { version = "0.5.0", features = ["llvm13-0"] }
 miette = { version = "7.2.0", features = ["fancy", "syntect-highlighter"] }
 owo-colors = "4.1.0"
 pretty_assertions = "1.4.1"
diff --git a/src/main.rs b/src/main.rs
index da52895..1b9dd53 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -14,7 +14,14 @@ pub mod passer;
 const INPUT: &str = "
 fn main() {
     let string = \"Hello, world!\";
-    println(argument);
+    return 12;
+
+    {
+        let string = \"Hello, world!\";
+        return 12;
+    };
+
+    let abc = 12;
 }
 ";
 
@@ -41,6 +48,7 @@ fn main() {
     };
 
     let typing_pass = passer::typing::TypingPasser::pass(&symbol).unwrap();
+    let typing_pass = typing_pass.combine(passer::unused::UnusedPass::pass(&symbol).unwrap());
 
     for note in typing_pass.non_critical {
         println!("{:?}", note.with_source_code(INPUT));
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index 04ec6fb..fc11862 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -154,6 +154,18 @@ pub struct Expression<'de> {
     pub span: miette::SourceSpan,
 }
 
+impl Expression<'_> {
+    pub fn label(&self, label: impl Into<String>) -> miette::LabeledSpan {
+        miette::LabeledSpan::at(self.span, label)
+    }
+}
+
+impl Statement<'_> {
+    pub fn label(&self, label: impl Into<String>) -> miette::LabeledSpan {
+        miette::LabeledSpan::at(self.span, label)
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum ExpressionValue<'de> {
     Primitive(Primitive<'de>),
@@ -302,6 +314,26 @@ pub trait Spannable<'de>: Sized {
     }
 }
 
+pub trait CombineSpan {
+    fn combine(spans: Vec<SourceSpan>) -> SourceSpan {
+        let start = spans
+            .iter()
+            .min_by_key(|s| s.offset())
+            .map(|s| s.offset())
+            .unwrap_or(0);
+
+        let end = spans
+            .iter()
+            .max_by_key(|s| s.offset() + s.len())
+            .map(|s| s.offset() + s.len())
+            .unwrap_or(0);
+
+        SourceSpan::new(start.into(), end - start)
+    }
+}
+
+impl CombineSpan for SourceSpan {}
+
 impl<'de> Spannable<'de> for Expression<'de> {
     type Value = ExpressionValue<'de>;
 
diff --git a/src/passer/mod.rs b/src/passer/mod.rs
index 4c787fa..5addf84 100644
--- a/src/passer/mod.rs
+++ b/src/passer/mod.rs
@@ -1,9 +1,10 @@
 use std::collections::HashSet;
 
-use crate::parser::ast::Symbol;
+use crate::parser::ast::{Expression, ExpressionValue, Statement, StatementValue, Symbol};
 use miette::{Report, Result, SourceSpan};
 
 pub mod typing;
+pub mod unused;
 
 pub trait Passer {
     fn pass(ast: &Symbol<'_>) -> Result<PasserResult>;
diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
index 14e79a2..7cf8548 100644
--- a/src/passer/typing/mod.rs
+++ b/src/passer/typing/mod.rs
@@ -1,11 +1,15 @@
 use core::net;
 
 use super::{Passer, PasserResult};
-use crate::parser::{
-    ast::{
-        Expression, ExpressionValue, Spannable, Statement, StatementValue, Symbol, Type, TypeValue,
+use crate::{
+    parser::{
+        ast::{
+            Expression, ExpressionValue, Spannable, Statement, StatementValue, Symbol, Type,
+            TypeValue,
+        },
+        expression,
     },
-    expression,
+    passer::walk,
 };
 use miette::{Error, LabeledSpan, Report, Result};
 
diff --git a/src/passer/unused.rs b/src/passer/unused.rs
new file mode 100644
index 0000000..3353e5f
--- /dev/null
+++ b/src/passer/unused.rs
@@ -0,0 +1,75 @@
+use crate::parser::ast::CombineSpan;
+use crate::parser::ast::{Expression, ExpressionValue, Statement, StatementValue};
+use miette::{LabeledSpan, SourceSpan};
+
+use super::{walk, Passer, PasserResult};
+
+pub struct UnusedPass;
+
+impl Passer for UnusedPass {
+    fn pass(ast: &crate::parser::ast::Symbol<'_>) -> miette::Result<super::PasserResult> {
+        walk(
+            ast,
+            |s: &Statement<'_>| match &s.value {
+                StatementValue::Block(statements) => {
+                    let mut result = super::PasserResult::default();
+                    let mut has_passed_return = false;
+                    for statement in statements {
+                        if let StatementValue::Return(_) = statement.value {
+                            has_passed_return = true;
+                            println!("has passed return");
+                            continue;
+                        }
+
+                        if has_passed_return {
+                            println!("unreachable code");
+
+                            result.non_critical.push(miette::miette! {
+                                help = "unreachable code",
+                                "unreachable code"
+                            });
+                        }
+                    }
+                    Ok(result)
+                }
+                _ => Ok(PasserResult::default()),
+            },
+            |e: &Expression<'_>| match &e.value {
+                ExpressionValue::Block {
+                    statements,
+                    return_value,
+                } => {
+                    let mut result = super::PasserResult::default();
+                    let mut has_passed_return = false;
+                    let mut unreachable_spans = vec![];
+                    for statement in statements {
+                        if let StatementValue::Return(_) = statement.value {
+                            has_passed_return = true;
+                            println!("has passed return");
+                            continue;
+                        }
+
+                        if has_passed_return {
+                            unreachable_spans.push(statement.span);
+                        }
+                    }
+
+                    if has_passed_return {
+                        unreachable_spans.push(return_value.span);
+                    }
+
+                    if !unreachable_spans.is_empty() {
+                        result.non_critical.push(miette::miette! {
+                            labels = vec![LabeledSpan::at(SourceSpan::combine(unreachable_spans), "unreachable code")],
+                            help = "unreachable code",
+                            "unreachable code"
+                        });
+                    }
+
+                    Ok(result)
+                }
+                _ => Ok(PasserResult::default()),
+            },
+        )
+    }
+}

From 3772ae924c2d213b31f7a7f6de519d6638608cd4 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Sun, 29 Dec 2024 18:13:07 +0100
Subject: [PATCH 39/43] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20Refactor=20`typed`?=
 =?UTF-8?q?=20and=20`untyped`=20ast?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: chore
---
 src/main.rs                           |  50 ++++----
 src/parser/ast/mod.rs                 |  74 ++++++++++++
 src/parser/ast/typed.rs               |   0
 src/parser/{ast.rs => ast/untyped.rs} |  73 +-----------
 src/parser/expression/binary.rs       |   5 +-
 src/parser/expression/mod.rs          |   5 +-
 src/parser/expression/primitive.rs    |   5 +-
 src/parser/expression/unary.rs        |   5 +-
 src/parser/lookup.rs                  |   5 +-
 src/parser/mod.rs                     |  12 +-
 src/parser/statement.rs               |   7 +-
 src/parser/typechecker/mod.rs         |  16 +++
 src/parser/typing.rs                  |   5 +-
 src/passer/mod.rs                     | 133 ----------------------
 src/passer/typing/mod.rs              | 158 --------------------------
 src/passer/unused.rs                  |  75 ------------
 16 files changed, 157 insertions(+), 471 deletions(-)
 create mode 100644 src/parser/ast/mod.rs
 create mode 100644 src/parser/ast/typed.rs
 rename src/parser/{ast.rs => ast/untyped.rs} (82%)
 create mode 100644 src/parser/typechecker/mod.rs
 delete mode 100644 src/passer/mod.rs
 delete mode 100644 src/passer/typing/mod.rs
 delete mode 100644 src/passer/unused.rs

diff --git a/src/main.rs b/src/main.rs
index 1b9dd53..875a1bd 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,27 +1,22 @@
+use crate::parser::typechecker::TypeChecker;
 use lexer::{Lexer, TokenKind};
 use owo_colors::{Style, Styled};
 use parser::{
-    ast::{Expression, ExpressionValue, Statement},
+    ast::untyped::{Expression, ExpressionValue},
     Parser,
 };
-use passer::{typing::Typing, Passer};
 use std::vec;
 
 pub mod lexer;
 pub mod parser;
-pub mod passer;
 
 const INPUT: &str = "
-fn main() {
-    let string = \"Hello, world!\";
-    return 12;
-
-    {
-        let string = \"Hello, world!\";
-        return 12;
-    };
+enum Test: a, b, c;
 
-    let abc = 12;
+fn main() {
+    let a = 12;
+    let b = 'a';
+    let c = a + b;
 }
 ";
 
@@ -38,7 +33,9 @@ fn main() {
     }))
     .unwrap();
 
-    let mut parser = Parser::new(INPUT);
+    let lexer = Lexer::new(INPUT);
+
+    let mut parser = Parser::new(lexer);
     let symbol = match parser.parse() {
         Ok(symbol) => symbol,
         Err(err) => {
@@ -47,16 +44,27 @@ fn main() {
         }
     };
 
-    let typing_pass = passer::typing::TypingPasser::pass(&symbol).unwrap();
-    let typing_pass = typing_pass.combine(passer::unused::UnusedPass::pass(&symbol).unwrap());
+    let mut typechecker = TypeChecker::new(symbol);
+    let symbol = match typechecker.check() {
+        Ok(symbol) => symbol,
+        Err(err) => {
+            println!("{:?}", err.with_source_code(INPUT));
+            return;
+        }
+    };
 
-    for note in typing_pass.non_critical {
-        println!("{:?}", note.with_source_code(INPUT));
-    }
+    println!("{:?}", symbol);
 
-    for note in typing_pass.critical {
-        println!("{:?}", note.with_source_code(INPUT));
-    }
+    // let typing_pass = passer::typing::TypingPasser::pass(&symbol).unwrap();
+    //let typing_pass = typing_pass.combine(passer::unused::UnusedPass::pass(&symbol).unwrap());
+
+    // for note in typing_pass.non_critical {
+    //     println!("{:?}", note.with_source_code(INPUT));
+    // }
+
+    // for note in typing_pass.critical {
+    //     println!("{:?}", note.with_source_code(INPUT));
+    // }
 }
 
 struct SomHighlighter {}
diff --git a/src/parser/ast/mod.rs b/src/parser/ast/mod.rs
new file mode 100644
index 0000000..ba52892
--- /dev/null
+++ b/src/parser/ast/mod.rs
@@ -0,0 +1,74 @@
+use miette::SourceSpan;
+
+pub mod typed;
+pub mod untyped;
+
+pub trait Spannable<'de>: Sized {
+    type Value;
+
+    fn at(span: miette::SourceSpan, value: Self::Value) -> Self;
+
+    fn at_multiple(spans: Vec<impl Into<miette::SourceSpan>>, value: Self::Value) -> Self {
+        let spans = spans.into_iter().map(|s| s.into()).collect::<Vec<_>>();
+
+        let start = spans
+            .iter()
+            .min_by_key(|s| s.offset())
+            .map(|s| s.offset())
+            .unwrap_or(0);
+
+        let end = spans
+            .iter()
+            .max_by_key(|s| s.offset() + s.len())
+            .map(|s| s.offset() + s.len())
+            .unwrap_or(0);
+
+        let span = miette::SourceSpan::new(start.into(), end - start);
+
+        Self::at(span, value)
+    }
+}
+
+pub trait CombineSpan {
+    fn combine(spans: Vec<SourceSpan>) -> SourceSpan {
+        let start = spans
+            .iter()
+            .min_by_key(|s| s.offset())
+            .map(|s| s.offset())
+            .unwrap_or(0);
+
+        let end = spans
+            .iter()
+            .max_by_key(|s| s.offset() + s.len())
+            .map(|s| s.offset() + s.len())
+            .unwrap_or(0);
+
+        SourceSpan::new(start.into(), end - start)
+    }
+}
+
+impl CombineSpan for SourceSpan {}
+
+impl<'de> Spannable<'de> for untyped::Expression<'de> {
+    type Value = untyped::ExpressionValue<'de>;
+
+    fn at(span: miette::SourceSpan, value: Self::Value) -> Self {
+        Self { value, span }
+    }
+}
+
+impl<'de> Spannable<'de> for untyped::Statement<'de> {
+    type Value = untyped::StatementValue<'de>;
+
+    fn at(span: miette::SourceSpan, value: Self::Value) -> Self {
+        Self { value, span }
+    }
+}
+
+impl<'de> Spannable<'de> for untyped::Type<'de> {
+    type Value = untyped::TypeValue<'de>;
+
+    fn at(span: miette::SourceSpan, value: Self::Value) -> Self {
+        Self { value, span }
+    }
+}
diff --git a/src/parser/ast/typed.rs b/src/parser/ast/typed.rs
new file mode 100644
index 0000000..e69de29
diff --git a/src/parser/ast.rs b/src/parser/ast/untyped.rs
similarity index 82%
rename from src/parser/ast.rs
rename to src/parser/ast/untyped.rs
index fc11862..a74787e 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast/untyped.rs
@@ -1,6 +1,5 @@
-use std::{borrow::Cow, fmt::Display};
-
 use miette::SourceSpan;
+use std::{borrow::Cow, fmt::Display};
 
 #[derive(Debug, Clone)]
 pub enum Symbol<'de> {
@@ -287,73 +286,3 @@ impl Display for Type<'_> {
         }
     }
 }
-
-pub trait Spannable<'de>: Sized {
-    type Value;
-
-    fn at(span: miette::SourceSpan, value: Self::Value) -> Self;
-
-    fn at_multiple(spans: Vec<impl Into<miette::SourceSpan>>, value: Self::Value) -> Self {
-        let spans = spans.into_iter().map(|s| s.into()).collect::<Vec<_>>();
-
-        let start = spans
-            .iter()
-            .min_by_key(|s| s.offset())
-            .map(|s| s.offset())
-            .unwrap_or(0);
-
-        let end = spans
-            .iter()
-            .max_by_key(|s| s.offset() + s.len())
-            .map(|s| s.offset() + s.len())
-            .unwrap_or(0);
-
-        let span = miette::SourceSpan::new(start.into(), end - start);
-
-        Self::at(span, value)
-    }
-}
-
-pub trait CombineSpan {
-    fn combine(spans: Vec<SourceSpan>) -> SourceSpan {
-        let start = spans
-            .iter()
-            .min_by_key(|s| s.offset())
-            .map(|s| s.offset())
-            .unwrap_or(0);
-
-        let end = spans
-            .iter()
-            .max_by_key(|s| s.offset() + s.len())
-            .map(|s| s.offset() + s.len())
-            .unwrap_or(0);
-
-        SourceSpan::new(start.into(), end - start)
-    }
-}
-
-impl CombineSpan for SourceSpan {}
-
-impl<'de> Spannable<'de> for Expression<'de> {
-    type Value = ExpressionValue<'de>;
-
-    fn at(span: miette::SourceSpan, value: Self::Value) -> Self {
-        Self { value, span }
-    }
-}
-
-impl<'de> Spannable<'de> for Statement<'de> {
-    type Value = StatementValue<'de>;
-
-    fn at(span: miette::SourceSpan, value: Self::Value) -> Self {
-        Self { value, span }
-    }
-}
-
-impl<'de> Spannable<'de> for Type<'de> {
-    type Value = TypeValue<'de>;
-
-    fn at(span: miette::SourceSpan, value: Self::Value) -> Self {
-        Self { value, span }
-    }
-}
diff --git a/src/parser/expression/binary.rs b/src/parser/expression/binary.rs
index edb5078..59a1ce0 100644
--- a/src/parser/expression/binary.rs
+++ b/src/parser/expression/binary.rs
@@ -1,5 +1,8 @@
 use crate::parser::{
-    ast::{BinaryOperator, Expression, ExpressionValue, Spannable},
+    ast::{
+        untyped::{BinaryOperator, Expression, ExpressionValue},
+        Spannable,
+    },
     lookup::BindingPower,
     Parser,
 };
diff --git a/src/parser/expression/mod.rs b/src/parser/expression/mod.rs
index 9bb74e1..ad2357d 100644
--- a/src/parser/expression/mod.rs
+++ b/src/parser/expression/mod.rs
@@ -1,7 +1,10 @@
 use miette::Result;
 
 use super::{
-    ast::{Expression, ExpressionValue, Spannable},
+    ast::{
+        untyped::{Expression, ExpressionValue},
+        Spannable,
+    },
     Parser,
 };
 use crate::{lexer::TokenKind, parser::lookup::BindingPower};
diff --git a/src/parser/expression/primitive.rs b/src/parser/expression/primitive.rs
index cf004c5..38146da 100644
--- a/src/parser/expression/primitive.rs
+++ b/src/parser/expression/primitive.rs
@@ -1,7 +1,10 @@
 use crate::{
     lexer::{TokenKind, TokenValue},
     parser::{
-        ast::{Expression, ExpressionValue, Primitive, Spannable},
+        ast::{
+            untyped::{Expression, ExpressionValue, Primitive},
+            Spannable,
+        },
         Parser,
     },
 };
diff --git a/src/parser/expression/unary.rs b/src/parser/expression/unary.rs
index dbc414d..1cfbc1b 100644
--- a/src/parser/expression/unary.rs
+++ b/src/parser/expression/unary.rs
@@ -1,7 +1,10 @@
 use crate::{
     lexer::TokenKind,
     parser::{
-        ast::{Expression, ExpressionValue, Spannable, UnaryOperator},
+        ast::{
+            untyped::{Expression, ExpressionValue, UnaryOperator},
+            Spannable,
+        },
         lookup::BindingPower,
         Parser,
     },
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index cae018c..603bb89 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -1,5 +1,8 @@
 use super::{
-    ast::{Expression, ExpressionValue, Primitive, Spannable, Statement, StatementValue, Type},
+    ast::{
+        untyped::{Expression, ExpressionValue, Primitive, Statement, StatementValue, Type},
+        Spannable,
+    },
     expression, statement, typing, Parser,
 };
 use crate::lexer::{TokenKind, TokenValue};
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index f952b08..895c52b 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -1,5 +1,8 @@
 use crate::lexer::Lexer;
-use ast::{Spannable, Statement, StatementValue, Symbol};
+use ast::{
+    untyped::{Statement, StatementValue, Symbol},
+    Spannable,
+};
 use lookup::Lookup;
 use miette::Result;
 
@@ -7,6 +10,7 @@ pub mod ast;
 pub mod expression;
 pub mod lookup;
 pub mod statement;
+pub mod typechecker;
 pub mod typing;
 
 pub struct Parser<'de> {
@@ -15,9 +19,9 @@ pub struct Parser<'de> {
 }
 
 impl<'de> Parser<'de> {
-    pub fn new(input: &'de str) -> Self {
-        Parser {
-            lexer: Lexer::new(input),
+    pub fn new(lexer: Lexer<'de>) -> Self {
+        Self {
+            lexer,
             lookup: Lookup::default(),
         }
     }
diff --git a/src/parser/statement.rs b/src/parser/statement.rs
index 9c526ea..86610e0 100644
--- a/src/parser/statement.rs
+++ b/src/parser/statement.rs
@@ -1,7 +1,10 @@
 use super::{
     ast::{
-        EnumMemberDeclaration, FunctionHeader, ParameterDeclaration, Spannable, Statement,
-        StatementValue, StructMemberDeclaration,
+        untyped::{
+            EnumMemberDeclaration, FunctionHeader, ParameterDeclaration, Statement, StatementValue,
+            StructMemberDeclaration,
+        },
+        Spannable,
     },
     expression,
     lookup::BindingPower,
diff --git a/src/parser/typechecker/mod.rs b/src/parser/typechecker/mod.rs
new file mode 100644
index 0000000..6e478f3
--- /dev/null
+++ b/src/parser/typechecker/mod.rs
@@ -0,0 +1,16 @@
+use super::ast::{typed, untyped};
+use miette::Result;
+
+pub struct TypeChecker<'de> {
+    symbol: untyped::Symbol<'de>,
+}
+
+impl<'de> TypeChecker<'de> {
+    pub fn new(symbol: untyped::Symbol<'de>) -> Self {
+        Self { symbol }
+    }
+
+    pub fn check(&mut self) -> Result<typed::Symbol<'de>> {
+        Ok(self.symbol.clone())
+    }
+}
diff --git a/src/parser/typing.rs b/src/parser/typing.rs
index a49088b..bab3f7e 100644
--- a/src/parser/typing.rs
+++ b/src/parser/typing.rs
@@ -1,5 +1,8 @@
 use super::{
-    ast::{Spannable, Type, TypeValue},
+    ast::{
+        untyped::{Type, TypeValue},
+        Spannable,
+    },
     lookup::BindingPower,
     Parser,
 };
diff --git a/src/passer/mod.rs b/src/passer/mod.rs
deleted file mode 100644
index 5addf84..0000000
--- a/src/passer/mod.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-use std::collections::HashSet;
-
-use crate::parser::ast::{Expression, ExpressionValue, Statement, StatementValue, Symbol};
-use miette::{Report, Result, SourceSpan};
-
-pub mod typing;
-pub mod unused;
-
-pub trait Passer {
-    fn pass(ast: &Symbol<'_>) -> Result<PasserResult>;
-}
-
-#[derive(Default, Debug)]
-pub struct PasserResult {
-    pub non_critical: Vec<Report>,
-    pub critical: Vec<Report>,
-}
-
-impl PasserResult {
-    pub fn combine(mut self, other: PasserResult) -> Self {
-        self.non_critical.extend(other.non_critical);
-        self.critical.extend(other.critical);
-
-        self
-    }
-}
-
-pub fn walk<'de>(
-    symbol: &Symbol<'de>,
-    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
-    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
-) -> Result<PasserResult> {
-    match symbol {
-        Symbol::Statement(statement) => walk_statement(statement, statement_fn, expression_fn),
-        Symbol::Expression(expression) => walk_expression(expression, statement_fn, expression_fn),
-    }
-}
-
-fn walk_statement<'de>(
-    statement: &Statement<'de>,
-    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
-    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
-) -> Result<PasserResult> {
-    let mut result = statement_fn(statement)?;
-
-    match &statement.value {
-        StatementValue::Block(statements) => {
-            for statement in statements {
-                result = result.combine(walk_statement(statement, statement_fn, expression_fn)?);
-            }
-        }
-        StatementValue::Expression(expression) => {
-            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
-        }
-        StatementValue::Assignment { name, value } => {
-            result = result.combine(walk_expression(value, statement_fn, expression_fn)?);
-        }
-        StatementValue::Struct { name, fields } => {}
-        StatementValue::Enum { name, variants } => {}
-        StatementValue::Function { header, body } => {
-            result = result.combine(walk_expression(body, statement_fn, expression_fn)?);
-        }
-        StatementValue::Trait { name, functions } => {}
-        StatementValue::Return(expression) => {
-            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
-        }
-        StatementValue::Conditional {
-            condition,
-            truthy,
-            falsy,
-        } => {
-            result = result.combine(walk_expression(condition, statement_fn, expression_fn)?);
-            result = result.combine(walk_statement(truthy, statement_fn, expression_fn)?);
-            if let Some(falsy) = falsy {
-                result = result.combine(walk_statement(falsy, statement_fn, expression_fn)?);
-            }
-        }
-    }
-
-    Ok(result)
-}
-
-fn walk_expression<'de>(
-    expression: &Expression<'de>,
-    statement_fn: fn(&Statement<'de>) -> Result<PasserResult>,
-    expression_fn: fn(&Expression<'de>) -> Result<PasserResult>,
-) -> Result<PasserResult> {
-    let mut result = expression_fn(expression)?;
-
-    match &expression.value {
-        ExpressionValue::Binary {
-            operator,
-            left,
-            right,
-        } => {
-            result = result.combine(walk_expression(left, statement_fn, expression_fn)?);
-            result = result.combine(walk_expression(right, statement_fn, expression_fn)?);
-        }
-        ExpressionValue::Unary { operator, operand } => {
-            result = result.combine(walk_expression(operand, statement_fn, expression_fn)?);
-        }
-        ExpressionValue::Group(expression) => {
-            result = result.combine(walk_expression(expression, statement_fn, expression_fn)?);
-        }
-        ExpressionValue::Block {
-            statements,
-            return_value,
-        } => {
-            for statement in statements {
-                result = result.combine(walk_statement(statement, statement_fn, expression_fn)?);
-            }
-            result = result.combine(walk_expression(return_value, statement_fn, expression_fn)?);
-        }
-        ExpressionValue::Conditional {
-            condition,
-            truthy,
-            falsy,
-        } => {
-            result = result.combine(walk_expression(condition, statement_fn, expression_fn)?);
-            result = result.combine(walk_expression(truthy, statement_fn, expression_fn)?);
-            result = result.combine(walk_expression(falsy, statement_fn, expression_fn)?);
-        }
-        ExpressionValue::Call { callee, arguments } => {
-            result = result.combine(walk_expression(callee, statement_fn, expression_fn)?);
-            for argument in arguments {
-                result = result.combine(walk_expression(argument, statement_fn, expression_fn)?);
-            }
-        }
-        ExpressionValue::Primitive(_) => {}
-    }
-
-    Ok(result)
-}
diff --git a/src/passer/typing/mod.rs b/src/passer/typing/mod.rs
deleted file mode 100644
index 7cf8548..0000000
--- a/src/passer/typing/mod.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use core::net;
-
-use super::{Passer, PasserResult};
-use crate::{
-    parser::{
-        ast::{
-            Expression, ExpressionValue, Spannable, Statement, StatementValue, Symbol, Type,
-            TypeValue,
-        },
-        expression,
-    },
-    passer::walk,
-};
-use miette::{Error, LabeledSpan, Report, Result};
-
-pub struct TypingPasser;
-
-impl Passer for TypingPasser {
-    fn pass(ast: &Symbol<'_>) -> Result<PasserResult> {
-        fn check_expression(expression: &Expression<'_>) -> Result<PasserResult> {
-            Ok(PasserResult::default())
-        }
-
-        fn check_statement(statement: &Statement<'_>) -> Result<PasserResult> {
-            let mut critical = vec![];
-
-            let types = statement.possible_types();
-
-            let distinct_types = types.clone().into_iter().fold(vec![], |mut acc, ty| {
-                if !acc.iter().any(|t: &Type<'_>| t.value == ty.value) {
-                    acc.push(ty);
-                }
-                acc
-            });
-
-            if distinct_types.is_empty() || distinct_types.len() == 1 {
-                return Ok(PasserResult::default());
-            }
-
-            let labels = types
-                .iter()
-                .map(|ty| LabeledSpan::at(ty.span, format!("{}", ty)))
-                .collect::<Vec<_>>();
-
-            critical.push(miette::miette! {
-                labels = labels,
-                help = "statement has multiple possible types",
-                "{} has multiple possible types", statement.value
-            });
-
-            Ok(PasserResult {
-                critical,
-                non_critical: vec![],
-            })
-        }
-
-        walk(ast, check_statement, check_expression)
-    }
-}
-
-pub trait Typing<'de> {
-    fn possible_types(&self) -> Vec<Type<'de>>;
-}
-
-impl<'de> Typing<'de> for Expression<'de> {
-    fn possible_types(&self) -> Vec<Type<'de>> {
-        match &self.value {
-            ExpressionValue::Primitive(primitive) => vec![match primitive {
-                crate::parser::ast::Primitive::Integer(_) => {
-                    Type::at(self.span, TypeValue::Integer)
-                }
-                crate::parser::ast::Primitive::Decimal(_) => {
-                    Type::at(self.span, TypeValue::Decimal)
-                }
-                crate::parser::ast::Primitive::String(_) => Type::at(self.span, TypeValue::String),
-                crate::parser::ast::Primitive::Identifier(value) => {
-                    Type::at(self.span, TypeValue::Symbol(value.clone()))
-                }
-                crate::parser::ast::Primitive::Character(_) => {
-                    Type::at(self.span, TypeValue::Character)
-                }
-                crate::parser::ast::Primitive::Boolean(_) => {
-                    Type::at(self.span, TypeValue::Boolean)
-                }
-                crate::parser::ast::Primitive::Unit => Type::at(self.span, TypeValue::Unit),
-            }],
-            ExpressionValue::Binary {
-                operator: _,
-                left,
-                right,
-            } => {
-                let mut types = left.possible_types();
-                types.extend(right.possible_types());
-                types
-            }
-            ExpressionValue::Unary {
-                operator: _,
-                operand,
-            } => operand.possible_types(),
-            ExpressionValue::Group(expression) => expression.possible_types(),
-            ExpressionValue::Block {
-                statements: _,
-                return_value,
-            } => return_value.possible_types(),
-            ExpressionValue::Conditional {
-                condition: _,
-                truthy,
-                falsy,
-            } => {
-                let mut types = truthy.possible_types();
-                types.extend(falsy.possible_types());
-                types
-            }
-            ExpressionValue::Call {
-                callee,
-                arguments: _,
-            } => callee.possible_types(),
-        }
-    }
-}
-
-impl<'de> Typing<'de> for Statement<'de> {
-    fn possible_types(&self) -> Vec<Type<'de>> {
-        match &self.value {
-            StatementValue::Block(statements) => vec![],
-            StatementValue::Expression(expression) => expression.possible_types(),
-            StatementValue::Assignment { name: _, value } => value.possible_types(),
-            StatementValue::Struct { name, fields } => {
-                vec![Type::at(self.span, TypeValue::Symbol(name.clone()))]
-            }
-            StatementValue::Enum { name, variants } => {
-                vec![Type::at(self.span, TypeValue::Symbol(name.clone()))]
-            }
-            StatementValue::Function { header, body } => {
-                let mut types = body.possible_types();
-                if let Some(explicit_return_type) = &header.explicit_return_type {
-                    types.push(explicit_return_type.clone());
-                }
-                types
-            }
-            StatementValue::Trait { name, functions } => {
-                vec![Type::at(self.span, TypeValue::Symbol(name.clone()))]
-            }
-            StatementValue::Return(expression) => expression.possible_types(),
-            StatementValue::Conditional {
-                condition,
-                truthy,
-                falsy,
-            } => {
-                let mut types = truthy.possible_types();
-                if let Some(falsy) = falsy {
-                    types.extend(falsy.possible_types());
-                }
-                types
-            }
-        }
-    }
-}
diff --git a/src/passer/unused.rs b/src/passer/unused.rs
deleted file mode 100644
index 3353e5f..0000000
--- a/src/passer/unused.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use crate::parser::ast::CombineSpan;
-use crate::parser::ast::{Expression, ExpressionValue, Statement, StatementValue};
-use miette::{LabeledSpan, SourceSpan};
-
-use super::{walk, Passer, PasserResult};
-
-pub struct UnusedPass;
-
-impl Passer for UnusedPass {
-    fn pass(ast: &crate::parser::ast::Symbol<'_>) -> miette::Result<super::PasserResult> {
-        walk(
-            ast,
-            |s: &Statement<'_>| match &s.value {
-                StatementValue::Block(statements) => {
-                    let mut result = super::PasserResult::default();
-                    let mut has_passed_return = false;
-                    for statement in statements {
-                        if let StatementValue::Return(_) = statement.value {
-                            has_passed_return = true;
-                            println!("has passed return");
-                            continue;
-                        }
-
-                        if has_passed_return {
-                            println!("unreachable code");
-
-                            result.non_critical.push(miette::miette! {
-                                help = "unreachable code",
-                                "unreachable code"
-                            });
-                        }
-                    }
-                    Ok(result)
-                }
-                _ => Ok(PasserResult::default()),
-            },
-            |e: &Expression<'_>| match &e.value {
-                ExpressionValue::Block {
-                    statements,
-                    return_value,
-                } => {
-                    let mut result = super::PasserResult::default();
-                    let mut has_passed_return = false;
-                    let mut unreachable_spans = vec![];
-                    for statement in statements {
-                        if let StatementValue::Return(_) = statement.value {
-                            has_passed_return = true;
-                            println!("has passed return");
-                            continue;
-                        }
-
-                        if has_passed_return {
-                            unreachable_spans.push(statement.span);
-                        }
-                    }
-
-                    if has_passed_return {
-                        unreachable_spans.push(return_value.span);
-                    }
-
-                    if !unreachable_spans.is_empty() {
-                        result.non_critical.push(miette::miette! {
-                            labels = vec![LabeledSpan::at(SourceSpan::combine(unreachable_spans), "unreachable code")],
-                            help = "unreachable code",
-                            "unreachable code"
-                        });
-                    }
-
-                    Ok(result)
-                }
-                _ => Ok(PasserResult::default()),
-            },
-        )
-    }
-}

From fd92c5a51f80b4b1ab9ea3889d50b244db0b93bf Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Mon, 30 Dec 2024 00:21:19 +0100
Subject: [PATCH 40/43] =?UTF-8?q?=E2=9C=A8=20Allow=20for=20multiple=20type?=
 =?UTF-8?q?=20errors=20to=20be=20caught?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: minor
---
 Cargo.lock                    |  35 ++++++++--
 Cargo.toml                    |   1 +
 src/highlighter/mod.rs        |  77 +++++++++++++++++++++
 src/main.rs                   | 104 +++-------------------------
 src/parser/ast/mod.rs         | 125 +++++++++++++++++++++++++++++++++-
 src/parser/ast/untyped.rs     |  37 +---------
 src/parser/lookup.rs          |   4 +-
 src/parser/typechecker/mod.rs | 112 ++++++++++++++++++++++++++++--
 src/parser/typing.rs          |   3 +-
 9 files changed, 351 insertions(+), 147 deletions(-)
 create mode 100644 src/highlighter/mod.rs

diff --git a/Cargo.lock b/Cargo.lock
index 8fa2740..13ea908 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -229,7 +229,7 @@ dependencies = [
  "syntect",
  "terminal_size",
  "textwrap",
- "thiserror",
+ "thiserror 1.0.65",
  "unicode-width",
 ]
 
@@ -348,9 +348,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.89"
+version = "1.0.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
 dependencies = [
  "unicode-ident",
 ]
@@ -488,6 +488,7 @@ dependencies = [
  "owo-colors",
  "pretty_assertions",
  "regex",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
@@ -513,9 +514,9 @@ checksum = "b7401a30af6cb5818bb64852270bb722533397edcfc7344954a38f420819ece2"
 
 [[package]]
 name = "syn"
-version = "2.0.85"
+version = "2.0.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5023162dfcd14ef8f32034d8bcd4cc5ddc61ef7a247c024a33e24e1f24d21b56"
+checksum = "9c786062daee0d6db1132800e623df74274a0a87322d8e183338e01b3d98d058"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -539,7 +540,7 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "thiserror",
+ "thiserror 1.0.65",
  "walkdir",
  "yaml-rust",
 ]
@@ -571,7 +572,16 @@ version = "1.0.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d11abd9594d9b38965ef50805c5e469ca9cc6f197f883f717e0269a3057b3d5"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 1.0.65",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f072643fd0190df67a8bab670c20ef5d8737177d6ac6b2e9a236cb096206b2cc"
+dependencies = [
+ "thiserror-impl 2.0.9",
 ]
 
 [[package]]
@@ -585,6 +595,17 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "thiserror-impl"
+version = "2.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b50fa271071aae2e6ee85f842e2e28ba8cd2c5fb67f11fcb1fd70b276f9e7d4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "time"
 version = "0.3.36"
diff --git a/Cargo.toml b/Cargo.toml
index 793738d..729cc2f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,3 +11,4 @@ miette = { version = "7.2.0", features = ["fancy", "syntect-highlighter"] }
 owo-colors = "4.1.0"
 pretty_assertions = "1.4.1"
 regex = "1.10"
+thiserror = "2.0.9"
diff --git a/src/highlighter/mod.rs b/src/highlighter/mod.rs
new file mode 100644
index 0000000..8f2d3d3
--- /dev/null
+++ b/src/highlighter/mod.rs
@@ -0,0 +1,77 @@
+use owo_colors::{Style, Styled};
+
+use crate::lexer::{Lexer, TokenKind};
+
+pub struct SomHighlighter {}
+struct SomHighlighterState {}
+
+impl miette::highlighters::Highlighter for SomHighlighter {
+    fn start_highlighter_state<'h>(
+        &'h self,
+        _source: &dyn miette::SpanContents<'_>,
+    ) -> Box<dyn miette::highlighters::HighlighterState + 'h> {
+        Box::new(SomHighlighterState {})
+    }
+}
+
+impl miette::highlighters::HighlighterState for SomHighlighterState {
+    fn highlight_line<'s>(&mut self, line: &'s str) -> Vec<Styled<&'s str>> {
+        let mut sections: Vec<Styled<&'s str>> = vec![];
+
+        for word in line.split(' ') {
+            for token in Lexer::<'s>::new(word) {
+                let style: Style = match &token {
+                    Ok(token) => match &token.kind {
+                        // Comment / quote -> 92, 99, 112 + italic
+                        TokenKind::If
+                        | TokenKind::Else
+                        | TokenKind::Let
+                        | TokenKind::Struct
+                        | TokenKind::Enum
+                        | TokenKind::Function
+                        | TokenKind::Trait
+                        | TokenKind::Return => Style::new().fg_rgb::<197, 120, 221>(),
+                        TokenKind::Identifier => Style::new().fg_rgb::<224, 108, 117>(),
+                        TokenKind::String | TokenKind::Character => {
+                            Style::new().fg_rgb::<152, 195, 121>().italic()
+                        }
+                        TokenKind::Integer | TokenKind::Decimal => {
+                            Style::new().fg_rgb::<209, 154, 102>()
+                        }
+                        TokenKind::Boolean => Style::new().fg_rgb::<86, 156, 214>(),
+                        TokenKind::IntegerType
+                        | TokenKind::DecimalType
+                        | TokenKind::BooleanType
+                        | TokenKind::StringType
+                        | TokenKind::CharacterType => {
+                            Style::new().fg_rgb::<86, 156, 214>().italic()
+                        }
+                        TokenKind::Equal
+                        | TokenKind::LessThan
+                        | TokenKind::GreaterThan
+                        | TokenKind::LessThanOrEqual
+                        | TokenKind::GreaterThanOrEqual
+                        | TokenKind::Equality
+                        | TokenKind::Inequality
+                        | TokenKind::Percent
+                        | TokenKind::Not
+                        | TokenKind::And
+                        | TokenKind::Pipe
+                        | TokenKind::Caret
+                        | TokenKind::Or
+                        | TokenKind::Semicolon
+                        | TokenKind::Comma => Style::new().fg_rgb::<200, 200, 200>(),
+                        _ => Style::new().fg_rgb::<171, 178, 191>(),
+                    },
+                    Err(_) => return vec![Style::new().remove_all_effects().white().style(line)],
+                };
+
+                let token = token.unwrap();
+                sections.push(style.style(token.original));
+            }
+            sections.push(Style::new().remove_all_effects().style(" "));
+        }
+
+        sections
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 875a1bd..640ab14 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,12 +1,16 @@
 use crate::parser::typechecker::TypeChecker;
+use highlighter::SomHighlighter;
 use lexer::{Lexer, TokenKind};
+use miette::{miette, Diagnostic};
 use owo_colors::{Style, Styled};
 use parser::{
     ast::untyped::{Expression, ExpressionValue},
     Parser,
 };
 use std::vec;
+use thiserror::Error;
 
+pub mod highlighter;
 pub mod lexer;
 pub mod parser;
 
@@ -17,6 +21,7 @@ fn main() {
     let a = 12;
     let b = 'a';
     let c = a + b;
+    let c = a + b;
 }
 ";
 
@@ -33,6 +38,8 @@ fn main() {
     }))
     .unwrap();
 
+    let mut errors = vec![];
+
     let lexer = Lexer::new(INPUT);
 
     let mut parser = Parser::new(lexer);
@@ -44,99 +51,10 @@ fn main() {
         }
     };
 
-    let mut typechecker = TypeChecker::new(symbol);
-    let symbol = match typechecker.check() {
-        Ok(symbol) => symbol,
-        Err(err) => {
-            println!("{:?}", err.with_source_code(INPUT));
-            return;
-        }
-    };
-
-    println!("{:?}", symbol);
-
-    // let typing_pass = passer::typing::TypingPasser::pass(&symbol).unwrap();
-    //let typing_pass = typing_pass.combine(passer::unused::UnusedPass::pass(&symbol).unwrap());
-
-    // for note in typing_pass.non_critical {
-    //     println!("{:?}", note.with_source_code(INPUT));
-    // }
-
-    // for note in typing_pass.critical {
-    //     println!("{:?}", note.with_source_code(INPUT));
-    // }
-}
-
-struct SomHighlighter {}
-struct SomHighlighterState {}
-
-impl miette::highlighters::Highlighter for SomHighlighter {
-    fn start_highlighter_state<'h>(
-        &'h self,
-        _source: &dyn miette::SpanContents<'_>,
-    ) -> Box<dyn miette::highlighters::HighlighterState + 'h> {
-        Box::new(SomHighlighterState {})
-    }
-}
-
-impl miette::highlighters::HighlighterState for SomHighlighterState {
-    fn highlight_line<'s>(&mut self, line: &'s str) -> Vec<Styled<&'s str>> {
-        let mut sections: Vec<Styled<&'s str>> = vec![];
-
-        for word in line.split(' ') {
-            for token in Lexer::<'s>::new(word) {
-                let style: Style = match &token {
-                    Ok(token) => match &token.kind {
-                        // Comment / quote -> 92, 99, 112 + italic
-                        TokenKind::If
-                        | TokenKind::Else
-                        | TokenKind::Let
-                        | TokenKind::Struct
-                        | TokenKind::Enum
-                        | TokenKind::Function
-                        | TokenKind::Trait
-                        | TokenKind::Return => Style::new().fg_rgb::<197, 120, 221>(),
-                        TokenKind::Identifier => Style::new().fg_rgb::<224, 108, 117>(),
-                        TokenKind::String | TokenKind::Character => {
-                            Style::new().fg_rgb::<152, 195, 121>().italic()
-                        }
-                        TokenKind::Integer | TokenKind::Decimal => {
-                            Style::new().fg_rgb::<209, 154, 102>()
-                        }
-                        TokenKind::Boolean => Style::new().fg_rgb::<86, 156, 214>(),
-                        TokenKind::IntegerType
-                        | TokenKind::DecimalType
-                        | TokenKind::BooleanType
-                        | TokenKind::StringType
-                        | TokenKind::CharacterType => {
-                            Style::new().fg_rgb::<86, 156, 214>().italic()
-                        }
-                        TokenKind::Equal
-                        | TokenKind::LessThan
-                        | TokenKind::GreaterThan
-                        | TokenKind::LessThanOrEqual
-                        | TokenKind::GreaterThanOrEqual
-                        | TokenKind::Equality
-                        | TokenKind::Inequality
-                        | TokenKind::Percent
-                        | TokenKind::Not
-                        | TokenKind::And
-                        | TokenKind::Pipe
-                        | TokenKind::Caret
-                        | TokenKind::Or
-                        | TokenKind::Semicolon
-                        | TokenKind::Comma => Style::new().fg_rgb::<200, 200, 200>(),
-                        _ => Style::new().fg_rgb::<171, 178, 191>(),
-                    },
-                    Err(_) => return vec![Style::new().remove_all_effects().white().style(line)],
-                };
-
-                let token = token.unwrap();
-                sections.push(style.style(token.original));
-            }
-            sections.push(Style::new().remove_all_effects().style(" "));
-        }
+    let typechecker = TypeChecker::new(symbol);
+    errors.extend(typechecker.check());
 
-        sections
+    for error in errors {
+        println!("{:?}", miette!(error).with_source_code(INPUT));
     }
 }
diff --git a/src/parser/ast/mod.rs b/src/parser/ast/mod.rs
index ba52892..9ff1aa5 100644
--- a/src/parser/ast/mod.rs
+++ b/src/parser/ast/mod.rs
@@ -1,8 +1,129 @@
+use std::{borrow::Cow, fmt::Display};
+
 use miette::SourceSpan;
 
 pub mod typed;
 pub mod untyped;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Type<'de> {
+    pub value: TypeValue<'de>,
+    pub span: SourceSpan,
+}
+
+impl<'de> Type<'de> {
+    pub fn label(&self, text: impl Into<String>) -> miette::LabeledSpan {
+        miette::LabeledSpan::at(self.span, text.into())
+    }
+
+    pub fn unit(span: SourceSpan) -> Self {
+        Self {
+            value: TypeValue::Unit,
+            span,
+        }
+    }
+
+    pub fn boolean(span: SourceSpan) -> Self {
+        Self {
+            value: TypeValue::Boolean,
+            span,
+        }
+    }
+
+    pub fn integer(span: SourceSpan) -> Self {
+        Self {
+            value: TypeValue::Integer,
+            span,
+        }
+    }
+
+    pub fn decimal(span: SourceSpan) -> Self {
+        Self {
+            value: TypeValue::Decimal,
+            span,
+        }
+    }
+
+    pub fn character(span: SourceSpan) -> Self {
+        Self {
+            value: TypeValue::Character,
+            span,
+        }
+    }
+
+    pub fn string(span: SourceSpan) -> Self {
+        Self {
+            value: TypeValue::String,
+            span,
+        }
+    }
+
+    pub fn symbol(span: SourceSpan, name: Cow<'de, str>) -> Self {
+        Self {
+            value: TypeValue::Symbol(name),
+            span,
+        }
+    }
+
+    pub fn collection(span: SourceSpan, element: Type<'de>) -> Self {
+        Self {
+            value: TypeValue::Collection(Box::new(element)),
+            span,
+        }
+    }
+
+    pub fn set(span: SourceSpan, element: Type<'de>) -> Self {
+        Self {
+            value: TypeValue::Set(Box::new(element)),
+            span,
+        }
+    }
+
+    pub fn matches(&self, other: &Type<'de>) -> bool {
+        match (&self.value, &other.value) {
+            (TypeValue::Unit, TypeValue::Unit)
+            | (TypeValue::Boolean, TypeValue::Boolean)
+            | (TypeValue::Integer, TypeValue::Integer)
+            | (TypeValue::Decimal, TypeValue::Decimal)
+            | (TypeValue::Character, TypeValue::Character)
+            | (TypeValue::String, TypeValue::String) => true,
+            (TypeValue::Symbol(a), TypeValue::Symbol(b)) => a == b,
+            (TypeValue::Collection(a), TypeValue::Collection(b)) => a.matches(b),
+            (TypeValue::Set(a), TypeValue::Set(b)) => a.matches(b),
+            _ => false,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TypeValue<'de> {
+    Unit,
+    Boolean,
+    Integer,
+    Decimal,
+    Character,
+    String,
+    Symbol(Cow<'de, str>),
+    Collection(Box<Type<'de>>),
+    Set(Box<Type<'de>>),
+}
+
+impl Display for Type<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.value {
+            TypeValue::Unit => write!(f, "nothing"),
+            TypeValue::Boolean => write!(f, "a boolean"),
+            TypeValue::Integer => write!(f, "an integer"),
+            TypeValue::Decimal => write!(f, "a decimal"),
+            TypeValue::Character => write!(f, "a character"),
+            TypeValue::String => write!(f, "a string"),
+            TypeValue::Symbol(name) => write!(f, "{}", name),
+            TypeValue::Collection(element) => write!(f, "[{}]", element),
+            TypeValue::Set(element) => write!(f, "{{{}}}", element),
+        }
+    }
+}
+
 pub trait Spannable<'de>: Sized {
     type Value;
 
@@ -65,8 +186,8 @@ impl<'de> Spannable<'de> for untyped::Statement<'de> {
     }
 }
 
-impl<'de> Spannable<'de> for untyped::Type<'de> {
-    type Value = untyped::TypeValue<'de>;
+impl<'de> Spannable<'de> for Type<'de> {
+    type Value = TypeValue<'de>;
 
     fn at(span: miette::SourceSpan, value: Self::Value) -> Self {
         Self { value, span }
diff --git a/src/parser/ast/untyped.rs b/src/parser/ast/untyped.rs
index a74787e..4b2c731 100644
--- a/src/parser/ast/untyped.rs
+++ b/src/parser/ast/untyped.rs
@@ -1,4 +1,4 @@
-use miette::SourceSpan;
+use super::Type;
 use std::{borrow::Cow, fmt::Display};
 
 #[derive(Debug, Clone)]
@@ -251,38 +251,3 @@ pub enum UnaryOperator {
     Negate,
     Negative,
 }
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Type<'de> {
-    pub value: TypeValue<'de>,
-    pub span: SourceSpan,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum TypeValue<'de> {
-    Unit,
-    Boolean,
-    Integer,
-    Decimal,
-    Character,
-    String,
-    Symbol(Cow<'de, str>),
-    Collection(Box<Type<'de>>),
-    Set(Box<Type<'de>>),
-}
-
-impl Display for Type<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match &self.value {
-            TypeValue::Unit => write!(f, "nothing"),
-            TypeValue::Boolean => write!(f, "a boolean"),
-            TypeValue::Integer => write!(f, "an integer"),
-            TypeValue::Decimal => write!(f, "a decimal"),
-            TypeValue::Character => write!(f, "a character"),
-            TypeValue::String => write!(f, "a string"),
-            TypeValue::Symbol(name) => write!(f, "{}", name),
-            TypeValue::Collection(element) => write!(f, "[{}]", element),
-            TypeValue::Set(element) => write!(f, "{{{}}}", element),
-        }
-    }
-}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
index 603bb89..4c88dba 100644
--- a/src/parser/lookup.rs
+++ b/src/parser/lookup.rs
@@ -1,7 +1,7 @@
 use super::{
     ast::{
-        untyped::{Expression, ExpressionValue, Primitive, Statement, StatementValue, Type},
-        Spannable,
+        untyped::{Expression, ExpressionValue, Primitive, Statement, StatementValue},
+        Spannable, Type,
     },
     expression, statement, typing, Parser,
 };
diff --git a/src/parser/typechecker/mod.rs b/src/parser/typechecker/mod.rs
index 6e478f3..9aebfbe 100644
--- a/src/parser/typechecker/mod.rs
+++ b/src/parser/typechecker/mod.rs
@@ -1,16 +1,118 @@
-use super::ast::{typed, untyped};
-use miette::Result;
+use super::{
+    ast::{typed, untyped, Type},
+    expression,
+};
+use miette::{MietteDiagnostic, Report, Result};
 
 pub struct TypeChecker<'de> {
     symbol: untyped::Symbol<'de>,
+    errors: Vec<MietteDiagnostic>,
 }
 
 impl<'de> TypeChecker<'de> {
     pub fn new(symbol: untyped::Symbol<'de>) -> Self {
-        Self { symbol }
+        Self {
+            symbol,
+            errors: vec![],
+        }
     }
 
-    pub fn check(&mut self) -> Result<typed::Symbol<'de>> {
-        Ok(self.symbol.clone())
+    pub fn check(mut self) -> Vec<MietteDiagnostic> {
+        match self.symbol.clone() {
+            untyped::Symbol::Statement(statement) => {
+                self.check_statement(&statement);
+            }
+            untyped::Symbol::Expression(expression) => {
+                self.check_expression(&expression);
+            }
+        };
+
+        if self.errors.is_empty() {
+            vec![]
+        } else {
+            self.errors
+        }
+    }
+
+    fn check_statement(&mut self, statement: &untyped::Statement<'de>) {
+        match &statement.value {
+            untyped::StatementValue::Expression(expression) => self.check_expression(expression),
+            untyped::StatementValue::Block(statements) => {
+                for statement in statements {
+                    self.check_statement(statement);
+                }
+            }
+            untyped::StatementValue::Function { header, body } => self.check_expression(body),
+            untyped::StatementValue::Return(expression) => self.check_expression(expression),
+            untyped::StatementValue::Enum { name, variants } => {}
+            untyped::StatementValue::Struct { name, fields } => {}
+            untyped::StatementValue::Assignment { name, value } => self.check_expression(value),
+            _ => todo!("check_statement: {:?}", statement),
+        }
+    }
+
+    fn check_expression(&mut self, expression: &untyped::Expression<'de>) {
+        if let Err(err) = self.type_of(expression) {
+            self.errors.push(err);
+        }
+    }
+
+    fn type_of(
+        &mut self,
+        expression: &untyped::Expression<'de>,
+    ) -> Result<Type<'de>, MietteDiagnostic> {
+        match &expression.value {
+            untyped::ExpressionValue::Primitive(primitive) => match primitive {
+                untyped::Primitive::Integer(_) => Ok(Type::integer(expression.span)),
+                untyped::Primitive::Decimal(_) => Ok(Type::decimal(expression.span)),
+                untyped::Primitive::Boolean(_) => Ok(Type::boolean(expression.span)),
+                untyped::Primitive::String(_) => Ok(Type::string(expression.span)),
+                untyped::Primitive::Identifier(name) => {
+                    Ok(Type::symbol(expression.span, name.clone()))
+                }
+                untyped::Primitive::Character(_) => Ok(Type::character(expression.span)),
+                untyped::Primitive::Unit => Ok(Type::unit(expression.span)),
+            },
+            untyped::ExpressionValue::Group(expression) => self.type_of(expression),
+            untyped::ExpressionValue::Block {
+                statements,
+                return_value,
+            } => {
+                for statement in statements {
+                    self.check_statement(statement);
+                }
+
+                self.type_of(return_value)
+            }
+            untyped::ExpressionValue::Binary {
+                operator,
+                left,
+                right,
+            } => {
+                let left = self.type_of(left)?;
+                let right = self.type_of(right)?;
+                expect_match(left, right)
+            }
+            untyped::ExpressionValue::Unary { operator, operand } => self.type_of(operand),
+            _ => todo!("type_of: {:?}", expression),
+        }
+    }
+}
+
+fn expect_match<'de>(left: Type<'de>, right: Type<'de>) -> Result<Type<'de>, MietteDiagnostic> {
+    if left.matches(&right) {
+        Ok(left)
+    } else {
+        Err(MietteDiagnostic {
+            code: None,
+            severity: None,
+            url: None,
+            labels: Some(vec![
+                left.label(format!("{}", left)),
+                right.label(format!("{}", right)),
+            ]),
+            help: Some(format!("{} is not the same type as {}", left, right)),
+            message: "type mismatch".to_owned(),
+        })
     }
 }
diff --git a/src/parser/typing.rs b/src/parser/typing.rs
index bab3f7e..d09ec21 100644
--- a/src/parser/typing.rs
+++ b/src/parser/typing.rs
@@ -1,7 +1,6 @@
 use super::{
     ast::{
-        untyped::{Type, TypeValue},
-        Spannable,
+        Spannable, {Type, TypeValue},
     },
     lookup::BindingPower,
     Parser,

From 7c63be95ce8fb00bab980bb7ccfdc93f73d2dbf5 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Mon, 30 Dec 2024 00:42:08 +0100
Subject: [PATCH 41/43] =?UTF-8?q?=E2=9C=A8=20Check=20for=20binary=20operat?=
 =?UTF-8?q?ions?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: minor
---
 src/parser/ast/mod.rs         | 94 +++++++++++++++++++++++++++++------
 src/parser/typechecker/mod.rs | 57 +++++++++++++++++----
 2 files changed, 125 insertions(+), 26 deletions(-)

diff --git a/src/parser/ast/mod.rs b/src/parser/ast/mod.rs
index 9ff1aa5..cc93025 100644
--- a/src/parser/ast/mod.rs
+++ b/src/parser/ast/mod.rs
@@ -78,21 +78,6 @@ impl<'de> Type<'de> {
             span,
         }
     }
-
-    pub fn matches(&self, other: &Type<'de>) -> bool {
-        match (&self.value, &other.value) {
-            (TypeValue::Unit, TypeValue::Unit)
-            | (TypeValue::Boolean, TypeValue::Boolean)
-            | (TypeValue::Integer, TypeValue::Integer)
-            | (TypeValue::Decimal, TypeValue::Decimal)
-            | (TypeValue::Character, TypeValue::Character)
-            | (TypeValue::String, TypeValue::String) => true,
-            (TypeValue::Symbol(a), TypeValue::Symbol(b)) => a == b,
-            (TypeValue::Collection(a), TypeValue::Collection(b)) => a.matches(b),
-            (TypeValue::Set(a), TypeValue::Set(b)) => a.matches(b),
-            _ => false,
-        }
-    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -108,9 +93,86 @@ pub enum TypeValue<'de> {
     Set(Box<Type<'de>>),
 }
 
+impl<'de> TypeValue<'de> {
+    pub fn matches(&self, other: &TypeValue<'de>) -> bool {
+        match (&self, &other) {
+            (TypeValue::Unit, TypeValue::Unit)
+            | (TypeValue::Boolean, TypeValue::Boolean)
+            | (TypeValue::Integer, TypeValue::Integer)
+            | (TypeValue::Decimal, TypeValue::Decimal)
+            | (TypeValue::Character, TypeValue::Character)
+            | (TypeValue::String, TypeValue::String) => true,
+            (TypeValue::Symbol(a), TypeValue::Symbol(b)) => a == b,
+            (TypeValue::Collection(a), TypeValue::Collection(b)) => a.value.matches(&b.value),
+            (TypeValue::Set(a), TypeValue::Set(b)) => a.value.matches(&b.value),
+            _ => false,
+        }
+    }
+
+    pub fn is_numeric(&self) -> bool {
+        match self {
+            TypeValue::Integer | TypeValue::Decimal => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_primitive(&self) -> bool {
+        match self {
+            TypeValue::Unit
+            | TypeValue::Boolean
+            | TypeValue::Integer
+            | TypeValue::Decimal
+            | TypeValue::Character
+            | TypeValue::String => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_collection(&self) -> bool {
+        match self {
+            TypeValue::Collection(_) => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_set(&self) -> bool {
+        match self {
+            TypeValue::Set(_) => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_symbol(&self) -> bool {
+        match self {
+            TypeValue::Symbol(_) => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_unit(&self) -> bool {
+        match self {
+            TypeValue::Unit => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_boolean(&self) -> bool {
+        match self {
+            TypeValue::Boolean => true,
+            _ => false,
+        }
+    }
+}
+
 impl Display for Type<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match &self.value {
+        write!(f, "{}", self.value)
+    }
+}
+
+impl Display for TypeValue<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self {
             TypeValue::Unit => write!(f, "nothing"),
             TypeValue::Boolean => write!(f, "a boolean"),
             TypeValue::Integer => write!(f, "an integer"),
diff --git a/src/parser/typechecker/mod.rs b/src/parser/typechecker/mod.rs
index 9aebfbe..a71a3d5 100644
--- a/src/parser/typechecker/mod.rs
+++ b/src/parser/typechecker/mod.rs
@@ -1,5 +1,7 @@
+use std::fmt::format;
+
 use super::{
-    ast::{typed, untyped, Type},
+    ast::{typed, untyped, Type, TypeValue},
     expression,
 };
 use miette::{MietteDiagnostic, Report, Result};
@@ -27,11 +29,7 @@ impl<'de> TypeChecker<'de> {
             }
         };
 
-        if self.errors.is_empty() {
-            vec![]
-        } else {
-            self.errors
-        }
+        self.errors
     }
 
     fn check_statement(&mut self, statement: &untyped::Statement<'de>) {
@@ -91,7 +89,9 @@ impl<'de> TypeChecker<'de> {
             } => {
                 let left = self.type_of(left)?;
                 let right = self.type_of(right)?;
-                expect_match(left, right)
+                expect_allowed_binary_operation(&left, &right, operator)?;
+                expect_match(&left, &right)?;
+                Ok(left.clone())
             }
             untyped::ExpressionValue::Unary { operator, operand } => self.type_of(operand),
             _ => todo!("type_of: {:?}", expression),
@@ -99,9 +99,46 @@ impl<'de> TypeChecker<'de> {
     }
 }
 
-fn expect_match<'de>(left: Type<'de>, right: Type<'de>) -> Result<Type<'de>, MietteDiagnostic> {
-    if left.matches(&right) {
-        Ok(left)
+fn expect_allowed_binary_operation<'de>(
+    left: &Type<'de>,
+    right: &Type<'de>,
+    operator: &untyped::BinaryOperator,
+) -> Result<(), MietteDiagnostic> {
+    match operator {
+        untyped::BinaryOperator::Add
+        | untyped::BinaryOperator::Subtract
+        | untyped::BinaryOperator::Multiply
+        | untyped::BinaryOperator::Divide => {
+            if left.value.is_numeric() && right.value.is_numeric() {
+                Ok(())
+            } else {
+                let mut labels = vec![];
+
+                if !left.value.is_numeric() {
+                    labels.push(left.label(format!("{}", left)));
+                }
+
+                if !right.value.is_numeric() {
+                    labels.push(right.label(format!("{}", right)));
+                }
+
+                Err(MietteDiagnostic {
+                    code: None,
+                    severity: None,
+                    url: None,
+                    labels: Some(labels),
+                    help: Some(format!("only numeric types can be used for {}", operator)),
+                    message: format!("expected numeric types for {}", operator),
+                })
+            }
+        }
+        _ => todo!("expect_allowed_binary_operation: {:?}", operator),
+    }
+}
+
+fn expect_match<'de>(left: &Type<'de>, right: &Type<'de>) -> Result<(), MietteDiagnostic> {
+    if left.value.matches(&right.value) {
+        Ok(())
     } else {
         Err(MietteDiagnostic {
             code: None,

From 372b3c600b8d74fd8ec541a7eddcb3cd1093653c Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Mon, 30 Dec 2024 01:16:07 +0100
Subject: [PATCH 42/43] =?UTF-8?q?=E2=9C=A8=20Add=20type=20environment?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: minor
---
 src/main.rs                   | 11 +++--
 src/parser/ast/mod.rs         | 39 +++++++++++++--
 src/parser/typechecker/mod.rs | 91 +++++++++++++++++++++++++++--------
 3 files changed, 115 insertions(+), 26 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 640ab14..2462baf 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -18,10 +18,13 @@ const INPUT: &str = "
 enum Test: a, b, c;
 
 fn main() {
-    let a = 12;
-    let b = 'a';
-    let c = a + b;
-    let c = a + b;
+    let a = 'a';
+    let b = a;
+    let c = b;
+
+    let c = 1;
+
+    let d = 1 + x;
 }
 ";
 
diff --git a/src/parser/ast/mod.rs b/src/parser/ast/mod.rs
index cc93025..ef2d2f8 100644
--- a/src/parser/ast/mod.rs
+++ b/src/parser/ast/mod.rs
@@ -9,17 +9,30 @@ pub mod untyped;
 pub struct Type<'de> {
     pub value: TypeValue<'de>,
     pub span: SourceSpan,
+    pub original_span: Option<SourceSpan>,
 }
 
 impl<'de> Type<'de> {
-    pub fn label(&self, text: impl Into<String>) -> miette::LabeledSpan {
-        miette::LabeledSpan::at(self.span, text.into())
+    pub fn label(&self, text: impl Into<String>) -> Vec<miette::LabeledSpan> {
+        let mut labels = vec![];
+
+        labels.push(miette::LabeledSpan::at(self.span, text.into()));
+
+        if let Some(original_span) = self.original_span {
+            labels.push(miette::LabeledSpan::at(
+                original_span,
+                "original type declaration".to_string(),
+            ));
+        }
+
+        labels
     }
 
     pub fn unit(span: SourceSpan) -> Self {
         Self {
             value: TypeValue::Unit,
             span,
+            original_span: None,
         }
     }
 
@@ -27,6 +40,7 @@ impl<'de> Type<'de> {
         Self {
             value: TypeValue::Boolean,
             span,
+            original_span: None,
         }
     }
 
@@ -34,6 +48,7 @@ impl<'de> Type<'de> {
         Self {
             value: TypeValue::Integer,
             span,
+            original_span: None,
         }
     }
 
@@ -41,6 +56,7 @@ impl<'de> Type<'de> {
         Self {
             value: TypeValue::Decimal,
             span,
+            original_span: None,
         }
     }
 
@@ -48,6 +64,7 @@ impl<'de> Type<'de> {
         Self {
             value: TypeValue::Character,
             span,
+            original_span: None,
         }
     }
 
@@ -55,6 +72,7 @@ impl<'de> Type<'de> {
         Self {
             value: TypeValue::String,
             span,
+            original_span: None,
         }
     }
 
@@ -62,6 +80,7 @@ impl<'de> Type<'de> {
         Self {
             value: TypeValue::Symbol(name),
             span,
+            original_span: None,
         }
     }
 
@@ -69,6 +88,7 @@ impl<'de> Type<'de> {
         Self {
             value: TypeValue::Collection(Box::new(element)),
             span,
+            original_span: None,
         }
     }
 
@@ -76,8 +96,17 @@ impl<'de> Type<'de> {
         Self {
             value: TypeValue::Set(Box::new(element)),
             span,
+            original_span: None,
         }
     }
+
+    pub fn span(mut self, span: SourceSpan) -> Self {
+        if self.original_span.is_none() {
+            self.original_span = Some(self.span);
+        }
+        self.span = span;
+        self
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -252,6 +281,10 @@ impl<'de> Spannable<'de> for Type<'de> {
     type Value = TypeValue<'de>;
 
     fn at(span: miette::SourceSpan, value: Self::Value) -> Self {
-        Self { value, span }
+        Self {
+            value,
+            span,
+            original_span: None,
+        }
     }
 }
diff --git a/src/parser/typechecker/mod.rs b/src/parser/typechecker/mod.rs
index a71a3d5..aa02d78 100644
--- a/src/parser/typechecker/mod.rs
+++ b/src/parser/typechecker/mod.rs
@@ -1,4 +1,4 @@
-use std::fmt::format;
+use std::{borrow::Cow, collections::HashMap, fmt::format};
 
 use super::{
     ast::{typed, untyped, Type, TypeValue},
@@ -9,6 +9,7 @@ use miette::{MietteDiagnostic, Report, Result};
 pub struct TypeChecker<'de> {
     symbol: untyped::Symbol<'de>,
     errors: Vec<MietteDiagnostic>,
+    environment: Environment<'de>,
 }
 
 impl<'de> TypeChecker<'de> {
@@ -16,6 +17,7 @@ impl<'de> TypeChecker<'de> {
         Self {
             symbol,
             errors: vec![],
+            environment: Environment::new(None),
         }
     }
 
@@ -34,24 +36,39 @@ impl<'de> TypeChecker<'de> {
 
     fn check_statement(&mut self, statement: &untyped::Statement<'de>) {
         match &statement.value {
-            untyped::StatementValue::Expression(expression) => self.check_expression(expression),
+            untyped::StatementValue::Expression(expression) => {
+                self.check_expression(expression);
+            }
             untyped::StatementValue::Block(statements) => {
                 for statement in statements {
                     self.check_statement(statement);
                 }
             }
-            untyped::StatementValue::Function { header, body } => self.check_expression(body),
-            untyped::StatementValue::Return(expression) => self.check_expression(expression),
+            untyped::StatementValue::Function { header, body } => {
+                self.check_expression(body);
+            }
+            untyped::StatementValue::Return(expression) => {
+                self.check_expression(expression);
+            }
             untyped::StatementValue::Enum { name, variants } => {}
             untyped::StatementValue::Struct { name, fields } => {}
-            untyped::StatementValue::Assignment { name, value } => self.check_expression(value),
+            untyped::StatementValue::Assignment { name, value } => {
+                if let Some(expression_type) = self.check_expression(value) {
+                    println!("{}: {:?}", name, expression_type);
+                    self.environment.set(name.clone(), expression_type);
+                }
+            }
             _ => todo!("check_statement: {:?}", statement),
-        }
+        };
     }
 
-    fn check_expression(&mut self, expression: &untyped::Expression<'de>) {
-        if let Err(err) = self.type_of(expression) {
-            self.errors.push(err);
+    fn check_expression(&mut self, expression: &untyped::Expression<'de>) -> Option<Type<'de>> {
+        match self.type_of(expression) {
+            Ok(ty) => Some(ty),
+            Err(err) => {
+                self.errors.push(err);
+                None
+            }
         }
     }
 
@@ -65,9 +82,19 @@ impl<'de> TypeChecker<'de> {
                 untyped::Primitive::Decimal(_) => Ok(Type::decimal(expression.span)),
                 untyped::Primitive::Boolean(_) => Ok(Type::boolean(expression.span)),
                 untyped::Primitive::String(_) => Ok(Type::string(expression.span)),
-                untyped::Primitive::Identifier(name) => {
-                    Ok(Type::symbol(expression.span, name.clone()))
-                }
+                untyped::Primitive::Identifier(name) => self
+                    .environment
+                    .get(name)
+                    .cloned()
+                    .map(|e| e.span(expression.span))
+                    .ok_or_else(|| MietteDiagnostic {
+                        code: None,
+                        severity: None,
+                        url: None,
+                        labels: Some(vec![expression.label("undeclared variable")]),
+                        help: Some(format!("`{}` is not declared", name)),
+                        message: "undeclared variable".to_owned(),
+                    }),
                 untyped::Primitive::Character(_) => Ok(Type::character(expression.span)),
                 untyped::Primitive::Unit => Ok(Type::unit(expression.span)),
             },
@@ -99,6 +126,30 @@ impl<'de> TypeChecker<'de> {
     }
 }
 
+struct Environment<'de> {
+    parent: Option<Box<Environment<'de>>>,
+    bindings: HashMap<Cow<'de, str>, Type<'de>>,
+}
+
+impl<'de> Environment<'de> {
+    fn new(parent: Option<Environment<'de>>) -> Self {
+        Self {
+            parent: parent.map(Box::new),
+            bindings: HashMap::new(),
+        }
+    }
+
+    fn set(&mut self, name: Cow<'de, str>, ty: Type<'de>) {
+        self.bindings.insert(name, ty);
+    }
+
+    fn get(&self, name: &Cow<'de, str>) -> Option<&Type<'de>> {
+        self.bindings
+            .get(name)
+            .or_else(|| self.parent.as_ref().and_then(|parent| parent.get(name)))
+    }
+}
+
 fn expect_allowed_binary_operation<'de>(
     left: &Type<'de>,
     right: &Type<'de>,
@@ -115,11 +166,12 @@ fn expect_allowed_binary_operation<'de>(
                 let mut labels = vec![];
 
                 if !left.value.is_numeric() {
-                    labels.push(left.label(format!("{}", left)));
+                    labels.extend(left.label(format!("{} may not be used for {}", left, operator)));
                 }
 
                 if !right.value.is_numeric() {
-                    labels.push(right.label(format!("{}", right)));
+                    labels
+                        .extend(right.label(format!("{} may not be used for {}", right, operator)));
                 }
 
                 Err(MietteDiagnostic {
@@ -127,7 +179,7 @@ fn expect_allowed_binary_operation<'de>(
                     severity: None,
                     url: None,
                     labels: Some(labels),
-                    help: Some(format!("only numeric types can be used for {}", operator)),
+                    help: Some(format!("only numeric types may be used for {}", operator)),
                     message: format!("expected numeric types for {}", operator),
                 })
             }
@@ -140,14 +192,15 @@ fn expect_match<'de>(left: &Type<'de>, right: &Type<'de>) -> Result<(), MietteDi
     if left.value.matches(&right.value) {
         Ok(())
     } else {
+        let mut labels = vec![];
+        labels.extend(left.label(format!("{}", left)));
+        labels.extend(right.label(format!("{}", right)));
+
         Err(MietteDiagnostic {
             code: None,
             severity: None,
             url: None,
-            labels: Some(vec![
-                left.label(format!("{}", left)),
-                right.label(format!("{}", right)),
-            ]),
+            labels: Some(labels),
             help: Some(format!("{} is not the same type as {}", left, right)),
             message: "type mismatch".to_owned(),
         })

From c075dfc0ceef0c2d8f0075460f01286549113791 Mon Sep 17 00:00:00 2001
From: Lucas <lucas@somfic.dev>
Date: Mon, 30 Dec 2024 01:56:02 +0100
Subject: [PATCH 43/43] =?UTF-8?q?=E2=9C=A8=20Add=20scoped=20variables?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

semver: minor
---
 src/main.rs                   |  11 +--
 src/parser/typechecker/mod.rs | 138 +++++++++++++++++++---------------
 2 files changed, 85 insertions(+), 64 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 2462baf..8dc8e8e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -18,13 +18,14 @@ const INPUT: &str = "
 enum Test: a, b, c;
 
 fn main() {
-    let a = 'a';
-    let b = a;
-    let c = b;
+    let x = 'b';
 
-    let c = 1;
+    {
+        let x = 'a';
+        let y = 1 + x;
+    };
 
-    let d = 1 + x;
+    let y = 1 + x;
 }
 ";
 
diff --git a/src/parser/typechecker/mod.rs b/src/parser/typechecker/mod.rs
index aa02d78..fdadc95 100644
--- a/src/parser/typechecker/mod.rs
+++ b/src/parser/typechecker/mod.rs
@@ -1,4 +1,4 @@
-use std::{borrow::Cow, collections::HashMap, fmt::format};
+use std::{borrow::Cow, collections::HashMap};
 
 use super::{
     ast::{typed, untyped, Type, TypeValue},
@@ -6,64 +6,80 @@ use super::{
 };
 use miette::{MietteDiagnostic, Report, Result};
 
-pub struct TypeChecker<'de> {
-    symbol: untyped::Symbol<'de>,
+pub struct TypeChecker<'ast> {
+    symbol: untyped::Symbol<'ast>,
     errors: Vec<MietteDiagnostic>,
-    environment: Environment<'de>,
 }
 
-impl<'de> TypeChecker<'de> {
-    pub fn new(symbol: untyped::Symbol<'de>) -> Self {
+impl<'ast> TypeChecker<'ast> {
+    pub fn new(symbol: untyped::Symbol<'ast>) -> Self {
         Self {
             symbol,
             errors: vec![],
-            environment: Environment::new(None),
         }
     }
 
     pub fn check(mut self) -> Vec<MietteDiagnostic> {
+        // Initially, there is no parent environment
+        let mut environment = Environment::new(None);
+
         match self.symbol.clone() {
-            untyped::Symbol::Statement(statement) => {
-                self.check_statement(&statement);
+            untyped::Symbol::Statement(stmt) => {
+                self.check_statement(&stmt, &mut environment);
             }
-            untyped::Symbol::Expression(expression) => {
-                self.check_expression(&expression);
+            untyped::Symbol::Expression(expr) => {
+                self.check_expression(&expr, &environment);
             }
         };
 
         self.errors
     }
 
-    fn check_statement(&mut self, statement: &untyped::Statement<'de>) {
+    fn check_statement<'env>(
+        &mut self,
+        statement: &untyped::Statement<'ast>,
+        environment: &mut Environment<'env, 'ast>,
+    ) {
         match &statement.value {
-            untyped::StatementValue::Expression(expression) => {
-                self.check_expression(expression);
+            untyped::StatementValue::Expression(expr) => {
+                self.check_expression(expr, environment);
             }
             untyped::StatementValue::Block(statements) => {
-                for statement in statements {
-                    self.check_statement(statement);
+                // Create a new child environment
+                let mut environment = Environment::new(Some(environment));
+
+                for stmt in statements {
+                    self.check_statement(stmt, &mut environment);
                 }
             }
             untyped::StatementValue::Function { header, body } => {
-                self.check_expression(body);
+                self.check_expression(body, environment);
             }
-            untyped::StatementValue::Return(expression) => {
-                self.check_expression(expression);
+            untyped::StatementValue::Return(expr) => {
+                self.check_expression(expr, environment);
+            }
+            untyped::StatementValue::Enum { name, variants } => {
+                // Not implemented yet
+            }
+            untyped::StatementValue::Struct { name, fields } => {
+                // Not implemented yet
             }
-            untyped::StatementValue::Enum { name, variants } => {}
-            untyped::StatementValue::Struct { name, fields } => {}
             untyped::StatementValue::Assignment { name, value } => {
-                if let Some(expression_type) = self.check_expression(value) {
+                if let Some(expression_type) = self.check_expression(value, environment) {
                     println!("{}: {:?}", name, expression_type);
-                    self.environment.set(name.clone(), expression_type);
+                    environment.set(name.clone(), expression_type);
                 }
             }
             _ => todo!("check_statement: {:?}", statement),
         };
     }
 
-    fn check_expression(&mut self, expression: &untyped::Expression<'de>) -> Option<Type<'de>> {
-        match self.type_of(expression) {
+    fn check_expression<'env>(
+        &mut self,
+        expression: &untyped::Expression<'ast>,
+        environment: &'env Environment<'env, 'ast>,
+    ) -> Option<Type<'ast>> {
+        match self.type_of(expression, environment) {
             Ok(ty) => Some(ty),
             Err(err) => {
                 self.errors.push(err);
@@ -72,21 +88,21 @@ impl<'de> TypeChecker<'de> {
         }
     }
 
-    fn type_of(
+    fn type_of<'env>(
         &mut self,
-        expression: &untyped::Expression<'de>,
-    ) -> Result<Type<'de>, MietteDiagnostic> {
+        expression: &untyped::Expression<'ast>,
+        environment: &Environment<'env, 'ast>,
+    ) -> Result<Type<'ast>, MietteDiagnostic> {
         match &expression.value {
             untyped::ExpressionValue::Primitive(primitive) => match primitive {
                 untyped::Primitive::Integer(_) => Ok(Type::integer(expression.span)),
                 untyped::Primitive::Decimal(_) => Ok(Type::decimal(expression.span)),
                 untyped::Primitive::Boolean(_) => Ok(Type::boolean(expression.span)),
                 untyped::Primitive::String(_) => Ok(Type::string(expression.span)),
-                untyped::Primitive::Identifier(name) => self
-                    .environment
+                untyped::Primitive::Identifier(name) => environment
                     .get(name)
                     .cloned()
-                    .map(|e| e.span(expression.span))
+                    .map(|ty| ty.span(expression.span))
                     .ok_or_else(|| MietteDiagnostic {
                         code: None,
                         severity: None,
@@ -98,61 +114,68 @@ impl<'de> TypeChecker<'de> {
                 untyped::Primitive::Character(_) => Ok(Type::character(expression.span)),
                 untyped::Primitive::Unit => Ok(Type::unit(expression.span)),
             },
-            untyped::ExpressionValue::Group(expression) => self.type_of(expression),
+            untyped::ExpressionValue::Group(expr) => self.type_of(expr, environment),
             untyped::ExpressionValue::Block {
                 statements,
                 return_value,
             } => {
-                for statement in statements {
-                    self.check_statement(statement);
+                // Child environment
+                let mut environment = Environment::new(Some(environment));
+
+                for stmt in statements {
+                    self.check_statement(stmt, &mut environment);
                 }
 
-                self.type_of(return_value)
+                self.type_of(return_value, &environment)
             }
             untyped::ExpressionValue::Binary {
                 operator,
                 left,
                 right,
             } => {
-                let left = self.type_of(left)?;
-                let right = self.type_of(right)?;
-                expect_allowed_binary_operation(&left, &right, operator)?;
-                expect_match(&left, &right)?;
-                Ok(left.clone())
+                let left_ty = self.type_of(left, environment)?;
+                let right_ty = self.type_of(right, environment)?;
+                expect_allowed_binary_operation(&left_ty, &right_ty, operator)?;
+                expect_match(&left_ty, &right_ty)?;
+                Ok(left_ty) // Return the type of the left side (they match anyway)
+            }
+            untyped::ExpressionValue::Unary { operator, operand } => {
+                self.type_of(operand, environment)
             }
-            untyped::ExpressionValue::Unary { operator, operand } => self.type_of(operand),
             _ => todo!("type_of: {:?}", expression),
         }
     }
 }
 
-struct Environment<'de> {
-    parent: Option<Box<Environment<'de>>>,
-    bindings: HashMap<Cow<'de, str>, Type<'de>>,
+struct Environment<'env, 'ast> {
+    parent: Option<&'env Environment<'env, 'ast>>,
+    bindings: HashMap<Cow<'env, str>, Type<'ast>>,
 }
 
-impl<'de> Environment<'de> {
-    fn new(parent: Option<Environment<'de>>) -> Self {
+impl<'env, 'ast> Environment<'env, 'ast> {
+    fn new(parent: Option<&'env Environment<'env, 'ast>>) -> Self {
         Self {
-            parent: parent.map(Box::new),
+            parent,
             bindings: HashMap::new(),
         }
     }
 
-    fn set(&mut self, name: Cow<'de, str>, ty: Type<'de>) {
+    fn set(&mut self, name: Cow<'env, str>, ty: Type<'ast>) {
         self.bindings.insert(name, ty);
     }
 
-    fn get(&self, name: &Cow<'de, str>) -> Option<&Type<'de>> {
+    fn get(&self, name: &Cow<'env, str>) -> Option<&Type<'ast>> {
         self.bindings
             .get(name)
-            .or_else(|| self.parent.as_ref().and_then(|parent| parent.get(name)))
+            .or_else(|| self.parent.and_then(|p| p.get(name)))
     }
 }
 
-fn expect_allowed_binary_operation<'de>(
-    left: &Type<'de>,
-    right: &Type<'de>,
+// Helper functions for type-checking
+
+fn expect_allowed_binary_operation<'a>(
+    left: &Type<'a>,
+    right: &Type<'a>,
     operator: &untyped::BinaryOperator,
 ) -> Result<(), MietteDiagnostic> {
     match operator {
@@ -164,23 +187,20 @@ fn expect_allowed_binary_operation<'de>(
                 Ok(())
             } else {
                 let mut labels = vec![];
-
                 if !left.value.is_numeric() {
                     labels.extend(left.label(format!("{} may not be used for {}", left, operator)));
                 }
-
                 if !right.value.is_numeric() {
                     labels
                         .extend(right.label(format!("{} may not be used for {}", right, operator)));
                 }
-
                 Err(MietteDiagnostic {
                     code: None,
                     severity: None,
                     url: None,
                     labels: Some(labels),
-                    help: Some(format!("only numeric types may be used for {}", operator)),
-                    message: format!("expected numeric types for {}", operator),
+                    help: Some(format!("only numeric types may be used for `{}`", operator)),
+                    message: format!("expected numeric types for `{}`", operator),
                 })
             }
         }
@@ -188,7 +208,7 @@ fn expect_allowed_binary_operation<'de>(
     }
 }
 
-fn expect_match<'de>(left: &Type<'de>, right: &Type<'de>) -> Result<(), MietteDiagnostic> {
+fn expect_match<'a>(left: &Type<'a>, right: &Type<'a>) -> Result<(), MietteDiagnostic> {
     if left.value.matches(&right.value) {
         Ok(())
     } else {