restructure fs

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;
+}

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

@@ -0,0 +1,177 @@
+namespace Nub.Lang.Frontend.Lexing;
+
+public class Lexer
+{
+    private static readonly Dictionary<string, Symbol> Keywords = new()
+    { 
+        ["func"] = Symbol.Func,
+        ["extern"] = Symbol.Extern,
+        ["import"] = Symbol.Import,
+        ["let"] = Symbol.Let,
+        ["if"] = Symbol.If,
+        ["else"] = Symbol.Else,
+        ["while"] = Symbol.While,
+        ["break"] = Symbol.Break,
+        ["continue"] = Symbol.Continue,
+        ["return"] = Symbol.Return,
+        ["new"] = Symbol.New,
+        ["struct"] = Symbol.Struct,
+    };
+
+    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 string _src = string.Empty;
+    private int _index;
+
+    public List<Token> Lex(string src)
+    {
+        _src = src;
+        _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++;
+    }
+}

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;
+}

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

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

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

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

lang/Nub.Lang/Frontend/Parsing/ArrayIndexAccessNode.cs

@@ -0,0 +1,9 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class ArrayIndexAccessNode(IdentifierNode identifier, ExpressionNode index) : ExpressionNode
+{
+    public IdentifierNode Identifier { get; } = identifier;
+    public ExpressionNode Index { get; } = index;
+
+    public override string ToString() => $"{Identifier}[{Index}]";
+}

lang/Nub.Lang/Frontend/Parsing/ArrayIndexAssignmentNode.cs

@@ -0,0 +1,8 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class ArrayIndexAssignmentNode(IdentifierNode identifier, ExpressionNode index, ExpressionNode value) : StatementNode
+{
+    public IdentifierNode Identifier { get; } = identifier;
+    public ExpressionNode Index { get; } = index;
+    public ExpressionNode Value { get; } = value;
+}

lang/Nub.Lang/Frontend/Parsing/ArrayInitializerNode.cs

@@ -0,0 +1,7 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class ArrayInitializerNode(long length, Type innerType) : ExpressionNode
+{
+    public long Length { get; } = length;
+    public Type InnerType { get; } = innerType;
+}

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
+}

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

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

lang/Nub.Lang/Frontend/Parsing/BreakNode.cs

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

lang/Nub.Lang/Frontend/Parsing/ContinueNode.cs

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

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

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

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;
+    }
+}

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

@@ -0,0 +1,10 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class ExternFuncDefinitionNode(string name, List<FuncParameter> parameters, Optional<Type> returnType) : DefinitionNode
+{
+    public string Name { get; } = name;
+    public List<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 : "")}";
+}

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

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

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();
+}

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();
+}

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;
+}

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

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

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

@@ -0,0 +1,8 @@
+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;
+}

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;
+}

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

@@ -0,0 +1,11 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class LocalFuncDefinitionNode(string name, List<FuncParameter> parameters, BlockNode body, Optional<Type> returnType) : DefinitionNode
+{
+    public string Name { get; } = name;
+    public List<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 : "")}";
+}

lang/Nub.Lang/Frontend/Parsing/ModuleNode.cs

@@ -0,0 +1,8 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class ModuleNode(string path, List<string> imports, List<DefinitionNode> definitions) : Node
+{
+    public string Path { get; } = path;
+    public List<string> Imports { get; } = imports;
+    public List<DefinitionNode> Definitions { get; } = definitions;
+}

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

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

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

@@ -0,0 +1,607 @@
+using System.Diagnostics.CodeAnalysis;
+using Nub.Lang.Frontend.Lexing;
+
+namespace Nub.Lang.Frontend.Parsing;
+
+public class Parser
+{
+    private List<Token> _tokens = [];
+    private int _index;
+    
+    public ModuleNode ParseModule(List<Token> tokens, string path)
+    {
+        _index = 0;
+        _tokens = tokens;
+        
+        List<DefinitionNode> definitions = [];
+        List<string> imports = [];
+        
+        while (Peek().HasValue)
+        {
+            if (TryExpectSymbol(Symbol.Import))
+            {
+                var name = ExpectLiteral();
+                if (name.Type is not StringType)
+                {
+                    throw new Exception("Import statements must have a string literal value");
+                }
+
+                TryExpectSymbol(Symbol.Semicolon);
+                imports.Add(name.Value);
+            }
+            else
+            {
+                definitions.Add(ParseDefinition());
+            }
+        }
+
+        return new ModuleNode(path, imports, definitions);
+    }
+
+    private DefinitionNode ParseDefinition()
+    {
+        var keyword = ExpectSymbol();
+        return keyword.Symbol switch
+        {
+            Symbol.Let => ParseGlobalVariableDefinition(),
+            Symbol.Func => ParseFuncDefinition(),
+            Symbol.Extern => ParseExternFuncDefinition(),
+            Symbol.Struct => ParseStruct(),
+            _ => 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 StructDefinitionNode ParseStruct()
+    {
+        var name = ExpectIdentifier().Value;
+
+        ExpectSymbol(Symbol.OpenBrace);
+        
+        List<StructMember> variables = [];
+        
+        while (!TryExpectSymbol(Symbol.CloseBrace))
+        {
+            ExpectSymbol(Symbol.Let);
+            var variableName = ExpectIdentifier().Value;
+            ExpectSymbol(Symbol.Colon);
+            var variableType = ParseType();
+
+            var variableValue = Optional<ExpressionNode>.Empty();
+            
+            if (TryExpectSymbol(Symbol.Assign))
+            {
+                variableValue = ParseExpression();
+            }
+            
+            ExpectSymbol(Symbol.Semicolon);
+            
+            variables.Add(new StructMember(variableName, variableType, variableValue));
+        }
+        
+        return new StructDefinitionNode(name, variables);
+    }
+
+    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.OpenBracket:
+                    {
+                        var index = ParseExpression();
+                        ExpectSymbol(Symbol.CloseBracket);
+                        ExpectSymbol(Symbol.Assign);
+                        var value = ParseExpression();
+                        ExpectSymbol(Symbol.Semicolon);
+                        return new ArrayIndexAssignmentNode(new IdentifierNode(identifier.Value), index, value);
+                    }
+                    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:
+            {
+                return symbol.Symbol switch
+                {
+                    Symbol.Return => ParseReturn(),
+                    Symbol.Let => ParseVariableAssignment(),
+                    Symbol.If => ParseIf(),
+                    Symbol.While => ParseWhile(),
+                    Symbol.Break => ParseBreak(),
+                    Symbol.Continue => ParseContinue(),
+                    _ => 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 WhileNode ParseWhile()
+    {
+        var condition = ParseExpression();
+        var body = ParseBlock();
+        return new WhileNode(condition, body);
+    }
+
+    private BreakNode ParseBreak()
+    {
+        ExpectSymbol(Symbol.Semicolon);
+        return new BreakNode();
+    }
+
+    private ContinueNode ParseContinue()
+    {
+        ExpectSymbol(Symbol.Semicolon);
+        return new ContinueNode();
+    }
+    
+    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 symbolToken:
+            {
+                switch (symbolToken.Symbol)
+                {
+                    case Symbol.OpenParen:
+                    {
+                        var expression = ParseExpression();
+                        ExpectSymbol(Symbol.CloseParen);
+                        return expression;
+                    }
+                    case Symbol.New:
+                    {
+                        var type = ParseType();
+                        switch (type)
+                        {
+                            case ArrayType:
+                            {
+                                ExpectSymbol(Symbol.OpenParen);
+                                var size = ExpectLiteral();
+                                if (size.Type is not PrimitiveType { Kind: PrimitiveTypeKind.Int64 })
+                                {
+                                    throw new Exception($"Array initializer size must be an {PrimitiveTypeKind.Int64}");
+                                }
+                                ExpectSymbol(Symbol.CloseParen);
+                            
+                                return new ArrayInitializerNode(long.Parse(size.Value), type);
+                            }
+                            case StructType structType:
+                            {
+                                Dictionary<string, ExpressionNode> initializers = [];
+                                ExpectSymbol(Symbol.OpenBrace);
+                                while (!TryExpectSymbol(Symbol.CloseBrace))
+                                {
+                                    var name = ExpectIdentifier().Value;
+                                    ExpectSymbol(Symbol.Assign);
+                                    var value = ParseExpression();
+                                    TryExpectSymbol(Symbol.Comma);
+                                    initializers.Add(name, value);
+                                }
+                            
+                                return new StructInitializerNode(structType, initializers);
+                            }
+                            default:
+                                throw new Exception($"Type {type} cannot be initialized with the new keyword");
+                        }
+                    }
+                    default:
+                        throw new Exception($"Unknown symbol: {symbolToken.Symbol}");
+                }
+            }
+            default: 
+                throw new Exception($"Unexpected token type {token.GetType().Name}");
+        }
+    }
+
+    private ExpressionNode ParseExpressionIdentifier(IdentifierToken identifier)
+    {
+        var token = Peek();
+        if (!token.HasValue)
+        {
+            return new IdentifierNode(identifier.Value);
+        }
+
+        switch (token.Value)
+        {
+            case SymbolToken symbolToken:
+            {
+                switch (symbolToken.Symbol)
+                {
+                    case Symbol.Period:
+                    {
+                        Next();
+                        List<string> members =
+                        [
+                            identifier.Value,
+                            ExpectIdentifier().Value
+                        ];
+
+                        while (TryExpectSymbol(Symbol.Period))
+                        {
+                            members.Add(ExpectIdentifier().Value);
+                        }
+
+                        return new StructMemberAccessorNode(members);
+                    }
+                    case Symbol.OpenBracket:
+                    {
+                        Next();
+                        var index = ParseExpression();
+                        ExpectSymbol(Symbol.CloseBracket);
+                        return new ArrayIndexAccessNode(new IdentifierNode(identifier.Value), index);
+                    }
+                    case Symbol.OpenParen:
+                    {
+                        Next();
+                        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));
+                    }
+                }
+                break;
+            }
+        }
+        
+        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;
+        switch (name)
+        {
+            case "String":
+            {
+                return new StringType();
+            }
+            case "Array":
+            {
+                ExpectSymbol(Symbol.LessThan);
+                var innerType = ParseType();
+                ExpectSymbol(Symbol.GreaterThan);
+                return new ArrayType(innerType);
+            }
+            case "Any":
+            {
+                return new AnyType();
+            }
+            default:
+            {
+                if (PrimitiveType.TryParse(name, out var primitiveType))
+                {
+                    return primitiveType;
+                }
+                
+                return new StructType(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.Count && _tokens.ElementAt(_index) is SymbolToken { Symbol: Symbol.Whitespace })
+        {
+            Next();
+        }
+
+        if (_index < _tokens.Count)
+        {
+            return _tokens.ElementAt(_index);
+        }
+
+        return Optional<Token>.Empty();
+    }
+
+    private void Next()
+    {
+        _index++;
+    }
+}

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

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

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

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

lang/Nub.Lang/Frontend/Parsing/StructDefinitionNode.cs

@@ -0,0 +1,7 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class StructDefinitionNode(string name, List<StructMember> members) : DefinitionNode
+{
+    public string Name { get; } = name;
+    public List<StructMember> Members { get; } = members;
+}

lang/Nub.Lang/Frontend/Parsing/StructInitializerNode.cs

@@ -0,0 +1,7 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class StructInitializerNode(StructType structType, Dictionary<string, ExpressionNode> initializers) : ExpressionNode
+{
+    public StructType StructType { get; } = structType;
+    public Dictionary<string, ExpressionNode> Initializers { get; } = initializers;
+}

lang/Nub.Lang/Frontend/Parsing/StructMemberAccessorNode.cs

@@ -0,0 +1,6 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class StructMemberAccessorNode(List<string> members) : ExpressionNode
+{
+    public List<string> Members { get; } = members;
+}

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

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

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;
+}

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;
+}

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;
+}

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;
+}

lang/Nub.Lang/Frontend/Parsing/WhileNode.cs

@@ -0,0 +1,7 @@
+namespace Nub.Lang.Frontend.Parsing;
+
+public class WhileNode(ExpressionNode condition, BlockNode body) : StatementNode
+{
+    public ExpressionNode Condition { get; } = condition;
+    public BlockNode Body { get; } = body;
+}

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

@@ -0,0 +1,392 @@
+using Nub.Lang.Frontend.Parsing;
+
+namespace Nub.Lang.Frontend.Typing;
+
+public class Func(string name, List<FuncParameter> parameters, Optional<BlockNode> body, Optional<Type> returnType)
+{
+    public string Name { get; } = name;
+    public List<FuncParameter> Parameters { get; } = parameters;
+    public Optional<BlockNode> Body { get; } = body;
+    public Optional<Type> ReturnType { get; } = returnType;
+}
+
+public class ExpressionTyper
+{
+    private readonly List<Func> _functions;
+    private readonly List<GlobalVariableDefinitionNode> _variableDefinitions;
+    private readonly List<StructDefinitionNode> _structDefinitions;
+    private readonly Stack<Variable> _variables;
+
+    public ExpressionTyper(List<DefinitionNode> definitions)
+    {
+        _variables = new Stack<Variable>();
+        _functions = [];
+        _variableDefinitions = [];
+        
+        _structDefinitions = definitions.OfType<StructDefinitionNode>().ToList();
+        
+        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.AddRange(functions);
+        _functions.AddRange(externFunctions);
+        _variableDefinitions.AddRange(definitions.OfType<GlobalVariableDefinitionNode>());
+    }
+
+    public void Populate()
+    {
+        _variables.Clear();
+        
+        foreach (var @class in _structDefinitions)
+        {
+            foreach (var variable in @class.Members)
+            {
+                if (variable.Value.HasValue)
+                {
+                    PopulateExpression(variable.Value.Value);
+                }
+            }
+        }
+        
+        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 ArrayIndexAssignmentNode arrayIndexAssignment:
+                PopulateArrayIndexAssignment(arrayIndexAssignment);
+                break;
+            case BreakNode:
+            case ContinueNode:
+                break;
+            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;
+            case WhileNode whileStatement:
+                PopulateWhileStatement(whileStatement);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(statement));
+        }
+    }
+
+    private void PopulateArrayIndexAssignment(ArrayIndexAssignmentNode arrayIndexAssignment)
+    {
+        PopulateIdentifier(arrayIndexAssignment.Identifier);
+        PopulateExpression(arrayIndexAssignment.Index);
+        PopulateExpression(arrayIndexAssignment.Value);
+    }
+
+    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 PopulateWhileStatement(WhileNode whileStatement)
+    {
+        PopulateExpression(whileStatement.Condition);
+        PopulateBlock(whileStatement.Body);
+    }
+
+    private void PopulateExpression(ExpressionNode expression)
+    {
+        switch (expression)
+        {
+            case ArrayIndexAccessNode arrayIndexAccess:
+                PopulateArrayIndexAccess(arrayIndexAccess);
+                break;
+            case ArrayInitializerNode arrayInitializer:
+                PopulateArrayInitializer(arrayInitializer);
+                break;
+            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 StructInitializerNode structInitializer:
+                PopulateStructInitializer(structInitializer);
+                break;
+            case StructMemberAccessorNode structMemberAccessor:
+                GenerateStructMemberAccessorNode(structMemberAccessor);
+                break;
+            case SyscallExpressionNode syscall:
+                PopulateSyscallExpression(syscall);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(expression));
+        }
+    }
+
+    private void PopulateArrayIndexAccess(ArrayIndexAccessNode arrayIndexAccess)
+    {
+        PopulateExpression(arrayIndexAccess.Index);
+        PopulateIdentifier(arrayIndexAccess.Identifier);
+        
+        var variable = _variables.FirstOrDefault(v => v.Name == arrayIndexAccess.Identifier.Identifier);
+        if (variable == null)
+        {
+            throw new Exception($"Variable {arrayIndexAccess.Identifier} is not defined");
+        }
+
+        if (variable.Type is not ArrayType arrayType)
+        {
+            throw new Exception($"Variable {arrayIndexAccess.Identifier} is not an array type");
+        }
+
+        arrayIndexAccess.Type = arrayType.InnerType;
+    }
+
+    private void PopulateArrayInitializer(ArrayInitializerNode arrayInitializer)
+    {
+        arrayInitializer.Type = arrayInitializer.InnerType;
+    }
+
+    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 PopulateStructInitializer(StructInitializerNode structInitializer)
+    {
+        foreach (var initializer in structInitializer.Initializers)
+        {
+            PopulateExpression(initializer.Value);
+        }
+
+        structInitializer.Type = structInitializer.StructType;
+    }
+
+    // TODO: Fix this ugly ass code
+    private void GenerateStructMemberAccessorNode(StructMemberAccessorNode structMemberAccessor)
+    {
+        var variable = _variables.FirstOrDefault(v => v.Name == structMemberAccessor.Members[0]);
+        if (variable == null)
+        {
+            throw new Exception($"Variable {structMemberAccessor.Members[0]} is not defined");
+        }
+
+        if (variable.Type is not StructType variableType)
+        {
+            throw new Exception("Variable " + structMemberAccessor.Members[0] + " is not a struct");
+        }
+        
+        var definition = _structDefinitions.FirstOrDefault(sd => sd.Name == variableType.Name);
+        if (definition == null)
+        {
+            throw new Exception($"Struct {structMemberAccessor.Members[0]} is not defined");
+        }
+
+        for (var i = 1; i < structMemberAccessor.Members.Count - 1; i++)
+        {
+            var member = definition.Members.FirstOrDefault(m => m.Name == structMemberAccessor.Members[i]);
+            if (member == null)
+            {
+                throw new Exception($"Member {structMemberAccessor.Members[i]} does not exist on struct {definition.Name}");
+            }
+
+            if (member.Type is not StructType memberType)
+            {
+                throw new Exception($"Member {structMemberAccessor.Members[i]} on struct {definition.Name} is not a struct");
+            }
+            
+            definition = _structDefinitions.FirstOrDefault(sd => sd.Name == memberType.Name);
+            if (definition == null)
+            {
+                throw new Exception($"Struct {structMemberAccessor.Members[i]} is not defined");
+            }
+        }
+        
+        var tmp = definition.Members.FirstOrDefault(m => m.Name == structMemberAccessor.Members.Last());
+        if (tmp == null)
+        {
+            throw new Exception($"Member {structMemberAccessor.Members.Last()} does not exist on struct {definition.Name}");
+        }
+        
+        structMemberAccessor.Type = tmp.Type;
+    }
+
+    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;
+    }
+}