Refactor

Nub.Lang/Nub.Lang/Frontend/Lexing/IdentifierToken.cs

@@ -0,0 +1,6 @@
+namespace Nub.Lang.Frontend.Lexing;
+
+public class IdentifierToken(string value) : Token
+{
+    public string Value { get; } = value;
+}

Nub.Lang/Nub.Lang/Frontend/Lexing/Lexer.cs

@@ -0,0 +1,176 @@
+using Nub.Core;
+
+namespace Nub.Lang.Frontend.Lexing;
+
+public class Lexer
+{
+    private static readonly Dictionary<string, Symbol> Keywords = new()
+    { 
+        ["func"] = Symbol.Func,
+        ["extern"] = Symbol.Extern,
+        ["return"] = Symbol.Return,
+        ["let"] = Symbol.Let,
+        ["if"] = Symbol.If,
+        ["else"] = Symbol.Else,
+    };
+
+    private static readonly Dictionary<char[], Symbol> Chians = new()
+    {
+        [['=', '=']] = Symbol.Equal,
+        [['!', '=']] = Symbol.NotEqual,
+        [['<', '=']] = Symbol.LessThanOrEqual,
+        [['>', '=']] = Symbol.GreaterThanOrEqual,
+    };
+    
+    private static readonly Dictionary<char, Symbol> Chars = new()
+    {
+        [';'] = Symbol.Semicolon,
+        [':'] = Symbol.Colon,
+        ['('] = Symbol.OpenParen,
+        [')'] = Symbol.CloseParen,
+        ['{'] = Symbol.OpenBrace,
+        ['}'] = Symbol.CloseBrace,
+        ['['] = Symbol.OpenBracket,
+        [']'] = Symbol.CloseBracket,
+        [','] = Symbol.Comma,
+        ['.'] = Symbol.Period,
+        ['='] = Symbol.Assign,
+        ['<'] = Symbol.LessThan,
+        ['>'] = Symbol.GreaterThan,
+        ['+'] = Symbol.Plus,
+        ['-'] = Symbol.Minus,
+        ['*'] = Symbol.Star,
+        ['/'] = Symbol.ForwardSlash,
+        ['!'] = Symbol.Bang,
+    };
+    
+    private readonly string _src;
+    private int _index;
+
+    public Lexer(string src)
+    {
+        _src = src;
+    }
+    
+    public IReadOnlyCollection<Token> Lex()
+    {
+        _index = 0;
+        List<Token> tokens = [];
+        while (Peek().HasValue)
+        {
+            tokens.Add(ParseToken());
+        }
+        return tokens;
+    }
+
+    private Token ParseToken()
+    {
+        var current = Peek();
+        
+        if (char.IsLetter(current.Value) || current.Value == '_')
+        {
+            var buffer = string.Empty;
+                
+            while (current.HasValue && (char.IsLetterOrDigit(current.Value) || current.Value == '_'))
+            {
+                buffer += current.Value;
+                Next();
+                current = Peek();
+            }
+
+            if (Keywords.TryGetValue(buffer, out var keywordSymbol))
+            {
+                return new SymbolToken(keywordSymbol);
+            }
+            
+            if (buffer is "true" or "false")
+            {
+                return new LiteralToken(new PrimitiveType(PrimitiveTypeKind.Bool), buffer);
+            }
+
+            return new IdentifierToken(buffer);
+        }
+
+        if (char.IsDigit(current.Value))
+        {
+            var buffer = string.Empty;
+                
+            while (current.HasValue && char.IsDigit(current.Value))
+            {
+                buffer += current.Value;
+                Next();
+                current = Peek();
+            }
+
+            return new LiteralToken(new PrimitiveType(PrimitiveTypeKind.Int64), buffer);
+        }
+
+        // TODO: Revisit this
+        foreach (var chain in Chians)
+        {
+            if (current.Value != chain.Key[0]) continue;
+            
+            for (var i = 1; i < chain.Key.Length; i++)
+            {
+                var c = Peek(i);
+                if (!c.HasValue || c.Value != chain.Key[i]) break;
+
+                if (i == chain.Key.Length - 1)
+                {
+                    for (var j = 0; j <= i; j++)
+                    {
+                        Next();
+                    }
+
+                    return new SymbolToken(chain.Value);
+                }
+            }
+        }
+
+        if (Chars.TryGetValue(current.Value, out var charSymbol))
+        {
+            Next();
+            return new SymbolToken(charSymbol);
+        }
+
+        if (current.Value == '"')
+        {
+            Next();
+            var buffer = string.Empty;
+            
+            while (true)
+            {
+                current = Peek();
+                Next();
+                if (!current.HasValue) throw new Exception("Unclosed string literal");
+                if (current.Value == '"') break;
+                buffer += current.Value;
+            }
+            
+            return new LiteralToken(new StringType(), buffer);
+        }
+
+        if (char.IsWhiteSpace(current.Value))
+        {
+            Next();
+            return new SymbolToken(Symbol.Whitespace);
+        }
+
+        throw new Exception($"Unknown character {current.Value}");
+    }
+
+    private Optional<char> Peek(int offset = 0)
+    {
+        if (_index + offset < _src.Length)
+        {
+            return _src[_index + offset];
+        }
+        
+        return Optional<char>.Empty();
+    }
+
+    private void Next()
+    {
+        _index++;
+    }
+}

Nub.Lang/Nub.Lang/Frontend/Lexing/LiteralToken.cs

@@ -0,0 +1,7 @@
+namespace Nub.Lang.Frontend.Lexing;
+
+public class LiteralToken(Type type, string value) : Token
+{
+    public Type Type { get; } = type;
+    public string Value { get; } = value;
+}

Nub.Lang/Nub.Lang/Frontend/Lexing/SymbolToken.cs

@@ -0,0 +1,39 @@
+namespace Nub.Lang.Frontend.Lexing;
+
+public class SymbolToken(Symbol symbol) : Token
+{
+    public Symbol Symbol { get; } = symbol;
+}
+
+public enum Symbol
+{
+    Whitespace,
+    Extern,
+    Func,
+    Return,
+    Let,
+    If,
+    Else,
+    Semicolon,
+    Colon,
+    OpenParen,
+    CloseParen,
+    OpenBrace,
+    CloseBrace,
+    OpenBracket,
+    CloseBracket,
+    Comma,
+    Period,
+    Assign,
+    Bang,
+    Equal,
+    NotEqual,
+    LessThan,
+    LessThanOrEqual,
+    GreaterThan,
+    GreaterThanOrEqual,
+    Plus,
+    Minus,
+    Star,
+    ForwardSlash,
+}

Nub.Lang/Nub.Lang/Frontend/Lexing/Token.cs

@@ -0,0 +1,3 @@
+namespace Nub.Lang.Frontend.Lexing;
+
+public abstract class Token;

Nub.Lang/Nub.Lang/Frontend/Parsing/BinaryExpressionNode.cs

@@ -0,0 +1,22 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class BinaryExpressionNode(ExpressionNode left, BinaryExpressionOperator @operator, ExpressionNode right) : ExpressionNode
+{
+    public ExpressionNode Left { get; } = left;
+    public BinaryExpressionOperator Operator { get; } = @operator;
+    public ExpressionNode Right { get; } = right;
+}
+
+public enum BinaryExpressionOperator
+{
+    Equal,
+    NotEqual,
+    GreaterThan,
+    GreaterThanOrEqual,
+    LessThan,
+    LessThanOrEqual,
+    Plus,
+    Minus,
+    Multiply,
+    Divide
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/BlockNode.cs

@@ -0,0 +1,6 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class BlockNode(IReadOnlyCollection<StatementNode> statements) : Node
+{
+    public IReadOnlyCollection<StatementNode> Statements { get; } = statements;
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/DefinitionNode.cs

@@ -0,0 +1,3 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public abstract class DefinitionNode : Node;

Nub.Lang/Nub.Lang/Frontend/Parsing/ExpressionNode.cs

@@ -0,0 +1,11 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public abstract class ExpressionNode : Node
+{
+    private Type? _type;
+    public Type Type
+    {
+        get => _type ?? throw new Exception("Tried to access expression type before type was populated");
+        set => _type = value;
+    }
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/ExternFuncDefinitionNode.cs

@@ -0,0 +1,12 @@
+using Nub.Core;
+
+namespace Nub.Lang.Frontend.Parsing;
+
+public class ExternFuncDefinitionNode(string name, IReadOnlyCollection<FuncParameter> parameters, Optional<Type> returnType) : DefinitionNode
+{
+    public string Name { get; } = name;
+    public IReadOnlyCollection<FuncParameter> Parameters { get; } = parameters;
+    public Optional<Type> ReturnType { get; } = returnType;
+
+    public override string ToString() => $"{Name}({string.Join(", ", Parameters.Select(p => p.ToString()))}){(ReturnType.HasValue ? ": " + ReturnType.Value : "")}";
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/FuncCall.cs

@@ -0,0 +1,9 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class FuncCall(string name, IReadOnlyCollection<ExpressionNode> parameters)
+{
+    public string Name { get; } = name;
+    public IReadOnlyCollection<ExpressionNode> Parameters { get; } = parameters;
+
+    public override string ToString() => $"{Name}()";
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/FuncCallExpressionNode.cs

@@ -0,0 +1,8 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class FuncCallExpressionNode(FuncCall funcCall) : ExpressionNode
+{
+    public FuncCall FuncCall { get; } = funcCall;
+
+    public override string ToString() => FuncCall.ToString();
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/FuncCallStatementNode.cs

@@ -0,0 +1,8 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class FuncCallStatementNode(FuncCall funcCall) : StatementNode
+{
+    public FuncCall FuncCall { get; } = funcCall;
+    
+    public override string ToString() => FuncCall.ToString();
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/GlobalVariableDefinitionNode.cs

@@ -0,0 +1,7 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class GlobalVariableDefinitionNode(string name, ExpressionNode value) : DefinitionNode
+{
+    public string Name { get; } = name;
+    public ExpressionNode Value { get; } = value;
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/IdentifierNode.cs

@@ -0,0 +1,11 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class IdentifierNode(string identifier) : ExpressionNode
+{
+    public string Identifier { get; } = identifier;
+
+    public override string ToString()
+    {
+        return Identifier;
+    }
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/IfNode.cs

@@ -0,0 +1,10 @@
+using Nub.Core;
+
+namespace Nub.Lang.Frontend.Parsing;
+
+public class IfNode(ExpressionNode condition, BlockNode body, Optional<Variant<IfNode, BlockNode>> @else) : StatementNode
+{
+    public ExpressionNode Condition { get; } = condition;
+    public BlockNode Body { get; } = body;
+    public Optional<Variant<IfNode, BlockNode>> Else { get; } = @else;
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/LiteralNode.cs

@@ -0,0 +1,7 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class LiteralNode(string literal, Type type) : ExpressionNode
+{
+    public string Literal { get; } = literal;
+    public Type LiteralType { get; } = type;
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/LocalFuncDefinitionNode.cs

@@ -0,0 +1,13 @@
+using Nub.Core;
+
+namespace Nub.Lang.Frontend.Parsing;
+
+public class LocalFuncDefinitionNode(string name, IReadOnlyCollection<FuncParameter> parameters, BlockNode body, Optional<Type> returnType) : DefinitionNode
+{
+    public string Name { get; } = name;
+    public IReadOnlyCollection<FuncParameter> Parameters { get; } = parameters;
+    public BlockNode Body { get; } = body;
+    public Optional<Type> ReturnType { get; } = returnType;
+
+    public override string ToString() => $"{Name}({string.Join(", ", Parameters.Select(p => p.ToString()))}){(ReturnType.HasValue ? ": " + ReturnType.Value : "")}";
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/Node.cs

@@ -0,0 +1,3 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public abstract class Node;

Nub.Lang/Nub.Lang/Frontend/Parsing/Parser.cs

@@ -0,0 +1,456 @@
+using System.Diagnostics.CodeAnalysis;
+using Nub.Core;
+using Nub.Lang.Frontend.Lexing;
+
+namespace Nub.Lang.Frontend.Parsing;
+
+public class Parser
+{
+    private readonly Token[] _tokens;
+    private int _index;
+
+    public Parser(IReadOnlyCollection<Token> tokens)
+    {
+        _tokens = tokens.ToArray();
+    }
+
+    public IReadOnlyCollection<DefinitionNode> Parse()
+    {
+        _index = 0;
+        List<DefinitionNode> definitions = [];
+        while (Peek().HasValue)
+        {
+            definitions.Add(ParseDefinition());
+        }
+
+        return definitions;
+    }
+
+    private DefinitionNode ParseDefinition()
+    {
+        var keyword = ExpectSymbol();
+        return keyword.Symbol switch
+        {
+            Symbol.Let => ParseGlobalVariableDefinition(),
+            Symbol.Func => ParseFuncDefinition(),
+            Symbol.Extern => ParseExternFuncDefinition(),
+            _ => throw new Exception("Unexpected symbol: " + keyword.Symbol)
+        };
+    }
+
+    private GlobalVariableDefinitionNode ParseGlobalVariableDefinition()
+    {
+        var name = ExpectIdentifier();
+        ExpectSymbol(Symbol.Assign);
+        var value = ParseExpression();
+        ExpectSymbol(Symbol.Semicolon);
+
+        return new GlobalVariableDefinitionNode(name.Value, value);
+    }
+
+    private LocalFuncDefinitionNode ParseFuncDefinition()
+    {
+        var name = ExpectIdentifier();
+        List<FuncParameter> parameters = [];
+        ExpectSymbol(Symbol.OpenParen);
+        if (!TryExpectSymbol(Symbol.CloseParen))
+        {
+            while (!TryExpectSymbol(Symbol.CloseParen))
+            {
+                parameters.Add(ParseFuncParameter());
+                TryExpectSymbol(Symbol.Comma);
+            }
+        }
+
+        var returnType = Optional<Type>.Empty();
+        if (TryExpectSymbol(Symbol.Colon))
+        {
+            returnType = ParseType();
+        }
+
+        var body = ParseBlock();
+
+        return new LocalFuncDefinitionNode(name.Value, parameters, body, returnType);
+    }
+
+    private ExternFuncDefinitionNode ParseExternFuncDefinition()
+    {
+        ExpectSymbol(Symbol.Func);
+        var name = ExpectIdentifier();
+        List<FuncParameter> parameters = [];
+        ExpectSymbol(Symbol.OpenParen);
+        if (!TryExpectSymbol(Symbol.CloseParen))
+        {
+            while (!TryExpectSymbol(Symbol.CloseParen))
+            {
+                parameters.Add(ParseFuncParameter());
+                TryExpectSymbol(Symbol.Comma);
+            }
+        }
+
+        var returnType = Optional<Type>.Empty();
+        if (TryExpectSymbol(Symbol.Colon))
+        {
+            returnType = ParseType();
+        }
+
+        ExpectSymbol(Symbol.Semicolon);
+        
+        return new ExternFuncDefinitionNode(name.Value, parameters, returnType);
+    }
+
+    private FuncParameter ParseFuncParameter()
+    {
+        var name = ExpectIdentifier();
+        ExpectSymbol(Symbol.Colon);
+        var type = ParseType();
+
+        return new FuncParameter(name.Value, type);
+    }
+
+    private StatementNode ParseStatement()
+    {
+        var token = ExpectToken();
+        switch (token)
+        {
+            case IdentifierToken identifier:
+            {
+                var symbol = ExpectSymbol();
+                switch (symbol.Symbol)
+                {
+                    case Symbol.OpenParen:
+                    {
+                        var parameters = new List<ExpressionNode>();
+                        while (!TryExpectSymbol(Symbol.CloseParen))
+                        {
+                            parameters.Add(ParseExpression());
+                            TryExpectSymbol(Symbol.Comma);
+                        }
+
+                        ExpectSymbol(Symbol.Semicolon);
+
+                        if (identifier.Value == "syscall")
+                        {
+                            return new SyscallStatementNode(new Syscall(parameters));
+                        }
+
+                        return new FuncCallStatementNode(new FuncCall(identifier.Value, parameters));
+                    }
+                    case Symbol.Assign:
+                    {
+                        var value = ParseExpression();
+                        ExpectSymbol(Symbol.Semicolon);
+                        return new VariableReassignmentNode(identifier.Value, value);
+                    }
+                    default:
+                    {
+                        throw new Exception($"Unexpected symbol {symbol.Symbol}");
+                    }
+                }
+            }
+            case SymbolToken symbol:
+            {
+                switch (symbol.Symbol)
+                {
+                    case Symbol.Return:
+                    {
+                        return ParseReturn();
+                    }
+                    case Symbol.Let:
+                    {
+                        return ParseVariableAssignment();
+                    }
+                    case Symbol.If:
+                    {
+                        return ParseIf();
+                    }
+                    default:
+                    {
+                        throw new Exception($"Unexpected symbol {symbol.Symbol}");
+                    }
+                }   
+            }
+            default:
+            {
+                throw new Exception($"Unexpected token type {token.GetType().Name}");
+            }
+        }
+    }
+
+    private ReturnNode ParseReturn()
+    {
+        var value = Optional<ExpressionNode>.Empty();
+        if (!TryExpectSymbol(Symbol.Semicolon))
+        {
+            value = ParseExpression();
+            ExpectSymbol(Symbol.Semicolon);
+        }
+
+        return new ReturnNode(value);
+    }
+
+    private VariableAssignmentNode ParseVariableAssignment()
+    {
+        var name = ExpectIdentifier().Value;
+        ExpectSymbol(Symbol.Assign);
+        var value = ParseExpression();
+        ExpectSymbol(Symbol.Semicolon);
+        
+        return new VariableAssignmentNode(name, value);
+    }
+
+    private IfNode ParseIf()
+    {
+        var condition = ParseExpression();
+        var body = ParseBlock();
+
+        var elseStatement = Optional<Variant<IfNode, BlockNode>>.Empty();
+        if (TryExpectSymbol(Symbol.Else))
+        {
+            elseStatement = TryExpectSymbol(Symbol.If)
+                ? (Variant<IfNode, BlockNode>)ParseIf()
+                : (Variant<IfNode, BlockNode>)ParseBlock();
+        }
+                        
+        return new IfNode(condition, body, elseStatement);
+    }
+
+    private ExpressionNode ParseExpression(int precedence = 0)
+    {
+        var left = ParsePrimaryExpression();
+
+        while (true)
+        {
+            var token = Peek();
+            if (!token.HasValue || token.Value is not SymbolToken symbolToken || !TryGetBinaryOperator(symbolToken.Symbol, out var op) || GetBinaryOperatorPrecedence(op.Value) < precedence)
+                break;
+            
+            Next();
+            var right = ParseExpression(GetBinaryOperatorPrecedence(op.Value) + 1);
+
+            left = new BinaryExpressionNode(left, op.Value, right);
+        }
+        
+        return left;
+    }
+
+    private static int GetBinaryOperatorPrecedence(BinaryExpressionOperator binaryExpressionOperator)
+    {
+        return binaryExpressionOperator switch
+        {
+            BinaryExpressionOperator.Multiply => 3,
+            BinaryExpressionOperator.Divide => 3,
+            BinaryExpressionOperator.Plus => 2,
+            BinaryExpressionOperator.Minus => 2,
+            BinaryExpressionOperator.GreaterThan => 1,
+            BinaryExpressionOperator.GreaterThanOrEqual => 1,
+            BinaryExpressionOperator.LessThan => 1,
+            BinaryExpressionOperator.LessThanOrEqual => 1,
+            BinaryExpressionOperator.Equal => 0,
+            BinaryExpressionOperator.NotEqual => 0,
+            _ => throw new ArgumentOutOfRangeException(nameof(binaryExpressionOperator), binaryExpressionOperator, null)
+        };
+    }
+
+    private static bool TryGetBinaryOperator(Symbol symbol, [NotNullWhen(true)] out BinaryExpressionOperator? binaryExpressionOperator)
+    {
+        switch (symbol)
+        {
+            case Symbol.Equal:
+                binaryExpressionOperator = BinaryExpressionOperator.Equal;
+                return true;
+            case Symbol.NotEqual:
+                binaryExpressionOperator = BinaryExpressionOperator.NotEqual;
+                return true;
+            case Symbol.LessThan:
+                binaryExpressionOperator = BinaryExpressionOperator.LessThan;
+                return true;
+            case Symbol.LessThanOrEqual:
+                binaryExpressionOperator = BinaryExpressionOperator.LessThanOrEqual;
+                return true;
+            case Symbol.GreaterThan:
+                binaryExpressionOperator = BinaryExpressionOperator.GreaterThan;
+                return true;
+            case Symbol.GreaterThanOrEqual:
+                binaryExpressionOperator = BinaryExpressionOperator.GreaterThanOrEqual;
+                return true;
+            case Symbol.Plus:
+                binaryExpressionOperator = BinaryExpressionOperator.Plus;
+                return true;
+            case Symbol.Minus:
+                binaryExpressionOperator = BinaryExpressionOperator.Minus;
+                return true;
+            case Symbol.Star:
+                binaryExpressionOperator = BinaryExpressionOperator.Multiply;
+                return true;
+            case Symbol.ForwardSlash:
+                binaryExpressionOperator = BinaryExpressionOperator.Divide;
+                return true;
+            default:
+                binaryExpressionOperator = null;
+                return false;
+        }
+    }
+
+    private ExpressionNode ParsePrimaryExpression()
+    {
+        var token = ExpectToken();
+        switch (token)
+        {
+            case LiteralToken literal:
+                return new LiteralNode(literal.Value, literal.Type);
+            case IdentifierToken identifier:
+                return ParseExpressionIdentifier(identifier);
+            case SymbolToken { Symbol: Symbol.OpenParen }:
+                var expression = ParseExpression();
+                ExpectSymbol(Symbol.CloseParen);
+                return expression;
+            default: 
+                throw new Exception($"Unexpected token type {token.GetType().Name}");
+        }
+    }
+
+    private ExpressionNode ParseExpressionIdentifier(IdentifierToken identifier)
+    {
+        if (TryExpectSymbol(Symbol.OpenParen))
+        {
+            List<ExpressionNode> parameters = [];
+            while (!TryExpectSymbol(Symbol.CloseParen))
+            {
+                parameters.Add(ParseExpression());
+                TryExpectSymbol(Symbol.Comma);
+            }
+            
+            if (identifier.Value == "syscall")
+            {
+                return new SyscallExpressionNode(new Syscall(parameters));
+            }
+
+            return new FuncCallExpressionNode(new FuncCall(identifier.Value, parameters));
+        }
+        
+        return new IdentifierNode(identifier.Value);
+    }
+
+    private BlockNode ParseBlock()
+    {
+        ExpectSymbol(Symbol.OpenBrace);
+        List<StatementNode> statements = [];
+        while (!TryExpectSymbol(Symbol.CloseBrace))
+        {
+            statements.Add(ParseStatement());
+        }
+
+        return new BlockNode(statements);
+    }
+
+    private Type ParseType()
+    {
+        var name = ExpectIdentifier().Value;
+        if (name == "Func")
+        {
+            List<Type> typeArguments = [];
+            if (TryExpectSymbol(Symbol.LessThan))
+            {
+                while (!TryExpectSymbol(Symbol.GreaterThan))
+                {
+                    var type = ParseType();
+                    typeArguments.Add(type);
+                    TryExpectSymbol(Symbol.Comma);
+                }
+            }
+
+            var returnType = Optional<Type>.OfNullable(typeArguments.LastOrDefault());
+
+            return new DelegateType(typeArguments.Take(typeArguments.Count - 1).ToList(), returnType);
+        }
+
+        if (name == "String")
+        {
+            return new StringType();
+        }
+
+        return PrimitiveType.Parse(name);
+    }
+
+    private Token ExpectToken()
+    {
+        var token = Peek();
+        if (!token.HasValue)
+        {
+            throw new Exception("Reached end of tokens");
+        }
+
+        Next();
+        return token.Value;
+    }
+
+    private SymbolToken ExpectSymbol()
+    {
+        var token = ExpectToken();
+        if (token is not SymbolToken symbol)
+        {
+            throw new Exception($"Expected {nameof(SymbolToken)} but got {token.GetType().Name}");
+        }
+
+        return symbol;
+    }
+
+    private void ExpectSymbol(Symbol symbol)
+    {
+        var token = ExpectSymbol();
+        if (token.Symbol != symbol)
+        {
+            throw new Exception($"Expected symbol {symbol} but got {token.Symbol}");
+        }
+    }
+
+    private bool TryExpectSymbol(Symbol symbol)
+    {
+        var result = Peek() is { HasValue: true, Value: SymbolToken symbolToken } && symbolToken.Symbol == symbol;
+        if (result) Next();
+        return result;
+    }
+
+    private IdentifierToken ExpectIdentifier()
+    {
+        var token = ExpectToken();
+        if (token is not IdentifierToken identifier)
+        {
+            throw new Exception($"Expected {nameof(IdentifierToken)} but got {token.GetType().Name}");
+        }
+
+        return identifier;
+    }
+
+    private LiteralToken ExpectLiteral()
+    {
+        var token = ExpectToken();
+        if (token is not LiteralToken literal)
+        {
+            throw new Exception($"Expected {nameof(LiteralToken)} but got {token.GetType().Name}");
+        }
+
+        return literal;
+    }
+
+    private Optional<Token> Peek()
+    {
+        while (_index < _tokens.Length && _tokens[_index] is SymbolToken { Symbol: Symbol.Whitespace })
+        {
+            Next();
+        }
+
+        if (_index < _tokens.Length)
+        {
+            return _tokens[_index];
+        }
+
+        return Optional<Token>.Empty();
+    }
+
+    private void Next()
+    {
+        _index++;
+    }
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/ReturnNode.cs

@@ -0,0 +1,8 @@
+using Nub.Core;
+
+namespace Nub.Lang.Frontend.Parsing;
+
+public class ReturnNode(Optional<ExpressionNode> value) : StatementNode
+{
+    public Optional<ExpressionNode> Value { get; } = value;
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/StatementNode.cs

@@ -0,0 +1,3 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public abstract class StatementNode : Node;

Nub.Lang/Nub.Lang/Frontend/Parsing/Syscall.cs

@@ -0,0 +1,6 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class Syscall(IReadOnlyCollection<ExpressionNode> parameters)
+{
+    public IReadOnlyCollection<ExpressionNode> Parameters { get; } = parameters;
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/SyscallExpressionNode.cs

@@ -0,0 +1,6 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class SyscallExpressionNode(Syscall syscall) : ExpressionNode
+{
+    public Syscall Syscall { get; } = syscall;
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/SyscallStatementNode.cs

@@ -0,0 +1,6 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class SyscallStatementNode(Syscall syscall) : StatementNode
+{
+    public Syscall Syscall { get; } = syscall;
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/VariableAssignmentNode.cs

@@ -0,0 +1,7 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class VariableAssignmentNode(string name, ExpressionNode value) : StatementNode
+{
+    public string Name { get; } = name;
+    public ExpressionNode Value { get; } = value;
+}

Nub.Lang/Nub.Lang/Frontend/Parsing/VariableReassignmentNode.cs

@@ -0,0 +1,7 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class VariableReassignmentNode(string name, ExpressionNode value) : StatementNode
+{
+    public string Name { get; } = name;
+    public ExpressionNode Value { get; } = value;
+}

Nub.Lang/Nub.Lang/Frontend/Typing/ExpressionTyper.cs

@@ -0,0 +1,258 @@
+using Nub.Core;
+using Nub.Lang.Frontend.Parsing;
+
+namespace Nub.Lang.Frontend.Typing;
+
+public class Func(string name, IReadOnlyCollection<FuncParameter> parameters, Optional<BlockNode> body, Optional<Type> returnType)
+{
+    public string Name { get; } = name;
+    public IReadOnlyCollection<FuncParameter> Parameters { get; } = parameters;
+    public Optional<BlockNode> Body { get; } = body;
+    public Optional<Type> ReturnType { get; } = returnType;
+}
+
+public class ExpressionTyper
+{
+    private readonly IReadOnlyCollection<Func> _functions;
+    private readonly IReadOnlyCollection<GlobalVariableDefinitionNode> _variableDefinitions;
+    private readonly Stack<Variable> _variables;
+
+    public ExpressionTyper(IReadOnlyCollection<DefinitionNode> definitions)
+    {
+        var functions = definitions
+            .OfType<LocalFuncDefinitionNode>()
+            .Select(f => new Func(f.Name, f.Parameters, f.Body, f.ReturnType))
+            .ToList();
+        
+        var externFunctions = definitions
+            .OfType<ExternFuncDefinitionNode>()
+            .Select(f => new Func(f.Name, f.Parameters, Optional<BlockNode>.Empty(), f.ReturnType))
+            .ToList();
+        
+        _functions = functions.Concat(externFunctions).ToList();
+        _variableDefinitions = definitions.OfType<GlobalVariableDefinitionNode>().ToList();
+        _variables = new Stack<Variable>();
+    }
+
+    public void Populate()
+    {
+        _variables.Clear();
+        
+        foreach (var variable in _variableDefinitions)
+        {
+            PopulateExpression(variable.Value);
+            _variables.Push(new Variable(variable.Name, variable.Value.Type));
+        }
+        
+        foreach (var function in _functions)
+        {
+            foreach (var parameter in function.Parameters)
+            {
+                _variables.Push(new Variable(parameter.Name, parameter.Type));
+            }
+
+            if (function.Body.HasValue)
+            {
+                PopulateBlock(function.Body.Value);
+            }
+            for (var i = 0; i < function.Parameters.Count; i++)
+            {
+                _variables.Pop();
+            }
+        }
+    }
+
+    private void PopulateBlock(BlockNode block)
+    {
+        var variableCount = _variables.Count;
+        foreach (var statement in block.Statements)
+        {
+            PopulateStatement(statement);
+        }
+        while (_variables.Count > variableCount)
+        {
+            _variables.Pop();
+        }
+    }
+
+    private void PopulateStatement(StatementNode statement)
+    {
+        switch (statement)
+        {
+            case FuncCallStatementNode funcCall:
+                PopulateFuncCallStatement(funcCall);
+                break;
+            case IfNode ifStatement:
+                PopulateIf(ifStatement);
+                break;
+            case ReturnNode returnNode:
+                PopulateReturn(returnNode);
+                break;
+            case SyscallStatementNode syscall:
+                PopulateSyscallStatement(syscall);
+                break;
+            case VariableAssignmentNode variableAssignment:
+                PopulateVariableAssignment(variableAssignment);
+                break;
+            case VariableReassignmentNode variableReassignment:
+                PopulateVariableReassignment(variableReassignment);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(statement));
+        }
+    }
+
+    private void PopulateFuncCallStatement(FuncCallStatementNode funcCall)
+    {
+        foreach (var parameter in funcCall.FuncCall.Parameters)
+        {
+            PopulateExpression(parameter);
+        }
+    }
+
+    private void PopulateIf(IfNode ifStatement)
+    {
+        PopulateExpression(ifStatement.Condition);
+        PopulateBlock(ifStatement.Body);
+        if (ifStatement.Else.HasValue)
+        {
+            ifStatement.Else.Value.Match
+            (
+                PopulateIf,
+                PopulateBlock
+            );
+        }
+    }
+
+    private void PopulateSyscallStatement(SyscallStatementNode syscall)
+    {
+        foreach (var parameter in syscall.Syscall.Parameters)
+        {
+            PopulateExpression(parameter);
+        }
+    }
+
+    private void PopulateReturn(ReturnNode returnNode)
+    {
+        if (returnNode.Value.HasValue)
+        {
+            PopulateExpression(returnNode.Value.Value);
+        }
+    }
+
+    private void PopulateVariableAssignment(VariableAssignmentNode variableAssignment)
+    {
+        PopulateExpression(variableAssignment.Value);
+        _variables.Push(new Variable(variableAssignment.Name, variableAssignment.Value.Type));
+    }
+
+    private void PopulateVariableReassignment(VariableReassignmentNode variableReassignment)
+    {
+        PopulateExpression(variableReassignment.Value);
+    }
+
+    private void PopulateExpression(ExpressionNode expression)
+    {
+        switch (expression)
+        {
+            case BinaryExpressionNode binaryExpression:
+                PopulateBinaryExpression(binaryExpression);
+                break;
+            case FuncCallExpressionNode funcCall:
+                PopulateFuncCallExpression(funcCall);
+                break;
+            case IdentifierNode identifier:
+                PopulateIdentifier(identifier);
+                break;
+            case LiteralNode literal:
+                PopulateLiteral(literal);
+                break;
+            case SyscallExpressionNode syscall:
+                PopulateSyscallExpression(syscall);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(expression));
+        }
+    }
+
+    private void PopulateBinaryExpression(BinaryExpressionNode binaryExpression)
+    {
+        PopulateExpression(binaryExpression.Left);
+        PopulateExpression(binaryExpression.Right);
+        switch (binaryExpression.Operator)
+        {
+            case BinaryExpressionOperator.Equal:
+            case BinaryExpressionOperator.NotEqual:
+            case BinaryExpressionOperator.GreaterThan:
+            case BinaryExpressionOperator.GreaterThanOrEqual:
+            case BinaryExpressionOperator.LessThan:
+            case BinaryExpressionOperator.LessThanOrEqual:
+            {
+                binaryExpression.Type = new PrimitiveType(PrimitiveTypeKind.Bool);
+                break;
+            }
+            case BinaryExpressionOperator.Plus:
+            case BinaryExpressionOperator.Minus:
+            case BinaryExpressionOperator.Multiply:
+            case BinaryExpressionOperator.Divide:
+            {
+                binaryExpression.Type = binaryExpression.Left.Type;
+                break;
+            }
+            default:
+            {
+                throw new ArgumentOutOfRangeException(nameof(binaryExpression.Operator));
+            }
+        }
+    }
+
+    private void PopulateFuncCallExpression(FuncCallExpressionNode funcCall)
+    {
+        foreach (var parameter in funcCall.FuncCall.Parameters)
+        {
+            PopulateExpression(parameter);
+        }
+                
+        var function = _functions.FirstOrDefault(f => f.Name == funcCall.FuncCall.Name);
+        if (function == null)
+        {
+            throw new Exception($"Func {funcCall} is not defined");
+        }
+        if (!function.ReturnType.HasValue)
+        {
+            throw new Exception($"Func {funcCall} must have a return type when used in an expression");
+        }
+        funcCall.Type = function.ReturnType.Value;
+    }
+
+    private void PopulateIdentifier(IdentifierNode identifier)
+    {
+        var type = _variables.FirstOrDefault(v => v.Name == identifier.Identifier)?.Type;
+        if (type == null)
+        {
+            throw new Exception($"Variable {identifier} is not defined");
+        }
+        identifier.Type = type;
+    }
+
+    private static void PopulateLiteral(LiteralNode literal)
+    {
+        literal.Type = literal.LiteralType;
+    }
+
+    private void PopulateSyscallExpression(SyscallExpressionNode syscall)
+    {
+        foreach (var parameter in syscall.Syscall.Parameters)
+        {
+            PopulateExpression(parameter);
+        }
+
+        syscall.Type = new PrimitiveType(PrimitiveTypeKind.Int64);
+    }
+
+    private class Variable(string name, Type type)
+    {
+        public string Name { get; } = name;
+        public Type Type { get; } = type;
+    }
+}