From 9c015720a0fa1acf10d43ffd7a006c4940f57ab6 Mon Sep 17 00:00:00 2001
From: Nathanne Isip <nathanneisip@gmail.com>
Date: Sun, 15 Sep 2024 09:09:41 +0800
Subject: [PATCH] Liquidated Parser class implementations.

---
 include/parser/Parser.hpp | 785 +++-----------------------------------
 1 file changed, 47 insertions(+), 738 deletions(-)

diff --git a/include/parser/Parser.hpp b/include/parser/Parser.hpp
index 88c33ea..1c4cee7 100644
--- a/include/parser/Parser.hpp
+++ b/include/parser/Parser.hpp
@@ -72,751 +72,60 @@ class Parser {
     int length;
     int index = 0;
 
+    std::unique_ptr<ASTNode> exprArray();
+    std::unique_ptr<ASTNode> exprBlock();
+    std::unique_ptr<ASTNode> exprCatchHandle();
+    std::unique_ptr<ASTNode> exprDoWhile();
+    std::unique_ptr<ASTNode> exprFunctionDecl();
+    std::unique_ptr<ASTNode> exprLoop();
+    std::unique_ptr<ASTNode> exprIf();
+    std::unique_ptr<ASTNode> exprLiteral();
+    std::unique_ptr<ASTNode> exprRandom();
+    std::unique_ptr<ASTNode> exprRender();
+    std::unique_ptr<ASTNode> exprType();
+    std::unique_ptr<ASTNode> exprUnless();
+    std::unique_ptr<ASTNode> exprWhen();
+    std::unique_ptr<ASTNode> exprWhile();
+    std::unique_ptr<ASTNode> exprPrimary();
+    std::unique_ptr<ASTNode> exprLogicOr();
+    std::unique_ptr<ASTNode> exprLogicAnd();
+    std::unique_ptr<ASTNode> exprBitwiseOr();
+    std::unique_ptr<ASTNode> exprBitwiseXor();
+    std::unique_ptr<ASTNode> exprBitwiseAnd();
+    std::unique_ptr<ASTNode> exprNilCoalescing();
+    std::unique_ptr<ASTNode> exprEquality();
+    std::unique_ptr<ASTNode> exprComparison();
+    std::unique_ptr<ASTNode> exprShift();
+    std::unique_ptr<ASTNode> exprTerm();
+    std::unique_ptr<ASTNode> exprFactor();
+
+    std::unique_ptr<ASTNode> stmtBreak();
+    std::unique_ptr<ASTNode> stmtContinue();
+    std::unique_ptr<ASTNode> stmtRet();
+    std::unique_ptr<ASTNode> stmtThrow();
+    std::unique_ptr<ASTNode> stmtTest();
+
+    std::unique_ptr<ASTNode> expression();
+    std::unique_ptr<ASTNode> statement();
+
+    Token peek() const;
+    Token consume(const std::string& image);
+    Token consume(TokenType type);
+
+    void advance();
+    bool isNext(const std::string& image) const;
+    bool isAtEnd() const;
+
 public:
     Parser(const std::vector<Token>& _tokens) :
         globalStatements{},
         tokens(_tokens),
         length(static_cast<int>(_tokens.size())) {}
 
-    static Parser fromFile(const std::string& fileName) {
-        std::unique_ptr<Tokenizer> tokenizer = Tokenizer::loadFile(fileName);
-        tokenizer->scan();
-
-        return Parser(tokenizer->getTokens());
-    }
-
-    bool isAtEnd() const {
-        return this->index == this->length;
-    }
-
-    void advance() {
-        this->index++;
-    }
-
-    Token peek() const {
-        if(this->isAtEnd())
-            throw ParserException("Encountered end-of-file.");
-
-        return this->tokens[this->index];
-    }
-
-    bool isNext(const std::string& image) const {
-        if(this->isAtEnd())
-            return false;
-
-        return this->peek().getImage() == image;
-    }
-
-    Token consume(const std::string& image) {
-        if(this->isAtEnd())
-            throw ParserException("Expecting \"" + image + "\", encountered end-of-code.");
-
-        Token token = this->peek();
-        if(token.getImage() != image)
-            throw ParserException("Expecting \"" + image + "\", encountered " + token.getImage());
-
-        this->advance();
-        return token;
-    }
-
-    Token consume(TokenType type) {
-        if(this->isAtEnd())
-            throw ParserException("Expecting token type, encountered end-of-code.");
-
-        Token token = this->peek();
-        if(token.getType() != type)
-            throw ParserException(
-                "Expecting " + tokenTypeToString(type) +
-                ", encountered " + tokenTypeToString(token.getType())
-            );
-
-        this->advance();
-        return token;
-    }
-
-    const std::vector<std::unique_ptr<ASTNode>>& getGlobalStatements() const {
-        return this->globalStatements;
-    }
-
-    std::unique_ptr<ASTNode> exprArray() {
-        Token address = this->consume("[");
-        std::vector<std::unique_ptr<ASTNode>> expressions;
-
-        while(!this->isNext("]")) {
-            if(!expressions.empty())
-                this->consume(",");
-
-            expressions.push_back(this->expression());
-        }
-
-        this->consume("]");
-        return std::make_unique<ArrayExpression>(
-            std::make_unique<Token>(address),
-            std::move(expressions)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprBlock() {
-        Token address = this->consume("{");
-        std::vector<std::unique_ptr<ASTNode>> body;
-
-        while(!this->isNext("}"))
-            body.emplace_back(this->expression());
-
-        return std::make_unique<BlockExpression>(
-            std::make_unique<Token>(address),
-            std::move(body)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprCatchHandle() {
-        Token address = this->consume("catch");
-        std::unique_ptr<ASTNode> catchExpr = this->expression();
-        this->consume("handle");
-
-        Token handler = this->consume(TokenType::IDENTIFIER);
-        std::unique_ptr<ASTNode> handleExpr = this->expression();
-
-        std::unique_ptr<ASTNode> finalExpr = nullptr;
-        if(this->isNext("handle")) {
-            this->consume("handle");
-            finalExpr = this->expression();
-        }
-
-        return std::make_unique<CatchHandleExpression>(
-            std::make_unique<Token>(address),
-            std::move(catchExpr),
-            std::move(handleExpr),
-            std::make_unique<Token>(handler),
-            std::move(finalExpr)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprDoWhile() {
-        Token address = this->consume("do");
-        std::unique_ptr<ASTNode> body = this->expression();
-
-        this->consume("while");
-        this->consume("(");
-
-        std::unique_ptr<ASTNode> condition = this->expression();
-        this->consume(")");
-
-        return std::make_unique<DoWhileExpression>(
-            std::make_unique<Token>(address),
-            std::move(body),
-            std::move(condition)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprFunctionDecl() {
-        Token address = this->consume("func");
-        this->consume("(");
-
-        std::vector<std::unique_ptr<Token>> parameters;
-        while(!this->isNext(")")) {
-            if(!parameters.empty())
-                this->consume(",");
-
-            parameters.emplace_back(
-                std::make_unique<Token>(
-                    this->consume(TokenType::IDENTIFIER)
-                )
-            );
-        }
-        this->consume(")");
-
-        std::unique_ptr<ASTNode> body = this->expression();
-        return std::make_unique<FunctionDeclarationExpression>(
-            std::make_unique<Token>(address),
-            std::move(parameters),
-            std::move(body)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprLoop() {
-        Token address = this->consume("loop");
-        this->consume("(");
-
-        std::unique_ptr<ASTNode> initial = this->expression();
-        this->consume(";");
-
-        std::unique_ptr<ASTNode> condition = this->expression();
-        this->consume(";");
-
-        std::unique_ptr<ASTNode> postexpr = this->expression();
-        this->consume(")");
-
-        std::unique_ptr<ASTNode> body = this->expression();
-        return std::make_unique<LoopExpression>(
-            std::make_unique<Token>(address),
-            std::move(initial),
-            std::move(condition),
-            std::move(postexpr),
-            std::move(body)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprIf() {
-        Token address = this->consume("if");
-        this->consume("(");
-
-        std::unique_ptr<ASTNode> condition = this->expression();
-        this->consume(")");
-
-        std::unique_ptr<ASTNode> thenExpr = this->expression();
-        std::unique_ptr<ASTNode> elseExpr = nullptr;
-
-        if(this->isNext("else")) {
-            this->consume("else");
-            elseExpr = this->expression();
-        }
-
-        return std::make_unique<IfElseExpression>(
-            std::make_unique<Token>(address),
-            std::move(condition),
-            std::move(thenExpr),
-            std::move(elseExpr)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprLiteral() {
-        std::unique_ptr<ASTNode> expr = nullptr;
-
-        if(this->isNext("true"))
-            expr = std::make_unique<BooleanLiteralExpression>(
-                std::make_unique<Token>(this->consume("true")),
-                true
-            );
-        else if(this->isNext("false"))
-            expr = std::make_unique<BooleanLiteralExpression>(
-                std::make_unique<Token>(this->consume("false")),
-                false
-            );
-        else if(this->isNext("maybe"))
-            expr = std::make_unique<MaybeExpression>(
-                std::make_unique<Token>(this->consume("maybe"))
-            );
-        else if(this->isNext("nil"))
-            expr = std::make_unique<NilLiteralExpression>(
-                std::make_unique<Token>(this->consume("nil"))
-            );
-        else if(this->peek().getType() == TokenType::STRING) {
-            Token stringToken = this->consume(TokenType::STRING);
-            expr = std::make_unique<StringLiteralExpression>(
-                std::make_unique<Token>(stringToken),
-                stringToken.getImage()
-            );
-        }
-        else if(this->peek().getType() == TokenType::DIGIT) {
-            Token digitToken = this->consume(TokenType::DIGIT);
-            expr = std::make_unique<NumberLiteralExpression>(
-                std::make_unique<Token>(digitToken),
-                ZhivoUtil::Convert::translateDigit(digitToken.getImage())
-            );
-        }
-
-        if(!expr)
-            throw ParserException(
-                "Expecting expression, encountered " +
-                this->peek().getImage()
-            );
-
-        return expr;
-    }
-
-    std::unique_ptr<ASTNode> exprRandom() {
-        Token address = this->consume("random");
-        std::unique_ptr<ASTNode> thenExpr = this->expression();
-        std::unique_ptr<ASTNode> elseExpr = nullptr;
-
-        if(this->isNext("else")) {
-            this->consume("else");
-            elseExpr = this->expression();
-        }
-
-        return std::make_unique<RandomExpression>(
-            std::make_unique<Token>(address),
-            std::move(thenExpr),
-            std::move(elseExpr)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprRender() {
-        Token address = this->consume("render");
-        std::unique_ptr<ASTNode> expression = this->expression();
-
-        return std::make_unique<RenderExpression>(
-            std::make_unique<Token>(address),
-            std::move(expression)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprType() {
-        Token address = this->consume("type");
-        std::unique_ptr<ASTNode> expression = this->expression();
-
-        return std::make_unique<TypeExpression>(
-            std::make_unique<Token>(address),
-            std::move(expression)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprUnless() {
-        Token address = this->consume("unless");
-        this->consume("(");
-
-        std::unique_ptr<ASTNode> condition = this->expression();
-        this->consume(")");
-
-        std::unique_ptr<ASTNode> thenExpr = this->expression();
-        std::unique_ptr<ASTNode> elseExpr = nullptr;
-
-        if(this->isNext("else")) {
-            this->consume("else");
-            elseExpr = this->expression();
-        }
-
-        return std::make_unique<UnlessExpression>(
-            std::make_unique<Token>(address),
-            std::move(condition),
-            std::move(thenExpr),
-            std::move(elseExpr)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprWhen() {
-        Token address = this->consume("when");
-        this->consume("(");
-
-        std::unique_ptr<ASTNode> expression = this->expression();
-        this->consume(")");
-        this->consume("{");
-
-        std::vector<std::pair<std::unique_ptr<ASTNode>, std::unique_ptr<ASTNode>>> cases;
-        std::unique_ptr<ASTNode> defaultCase = nullptr;
-
-        while(!this->isNext("}")) {
-            if(!cases.empty())
-                this->consume(",");
-            
-            if(this->isNext("if")) {
-                this->consume("if");
-                this->consume("(");
-
-                std::unique_ptr<ASTNode> caseExpr = this->expression();
-                this->consume(")");
-
-                std::unique_ptr<ASTNode> thenBlock = this->expression();
-                cases.emplace_back(std::make_pair(
-                    std::move(caseExpr),
-                    std::move(thenBlock)
-                ));
-            }
-            else if(this->isNext("else")) {
-                if(defaultCase)
-                    throw std::runtime_error("Cannot have more than one (1) else for when expression.");
-
-                this->consume("else");
-                defaultCase = this->expression();
-            }
-        }
-
-        return std::make_unique<WhenExpression>(
-            std::make_unique<Token>(address),
-            std::move(expression),
-            std::move(cases),
-            std::move(defaultCase)
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprWhile() {
-        Token address = this->consume("while");
-        this->consume("(");
-
-        std::unique_ptr<ASTNode> condition = this->expression();
-        this->consume(")");
-
-        return std::make_unique<WhileExpression>(
-            std::make_unique<Token>(address),
-            std::move(condition),
-            this->expression()
-        );
-    }
-
-    std::unique_ptr<ASTNode> exprPrimary() {
-        std::unique_ptr<ASTNode> expression = nullptr;
-
-        if(this->isNext("+") || this->isNext("-") || this->isNext("~")) {
-            Token address = this->consume(TokenType::OPERATOR);
-            expression = std::make_unique<UnaryExpression>(
-                std::make_unique<Token>(address),
-                std::move(std::string(address.getImage())),
-                this->expression()
-            );
-        }
-        else if(this->isNext("(")) {
-            Token address = this->consume("(");
-            std::unique_ptr<ASTNode> innerExpr = this->expression();
-
-            expression = std::make_unique<GroupedExpression>(
-                std::make_unique<Token>(address),
-                std::move(innerExpr)
-            );
-            this->consume(")");
-        }
-        else if(this->isNext("{")) {
-            Token address = this->consume(TokenType::IDENTIFIER);
-            std::vector<std::unique_ptr<ASTNode>> statements;
-
-            while(!this->isNext("}")) {
-                std::unique_ptr<ASTNode> stmt = this->statement();
-                statements.emplace_back(std::move(stmt));
-            }
-            this->consume("}");
-
-            expression = std::make_unique<BlockExpression>(
-                std::make_unique<Token>(address),
-                std::move(statements)
-            );
-        }
-        else if(this->isNext("render"))
-            expression = this->exprRender();
-        else if(this->isNext("catch"))
-            expression = this->exprCatchHandle();
-        else if(this->isNext("do"))
-            expression = this->exprDoWhile();
-        else if(this->isNext("while"))
-            expression = this->exprWhile();
-        else if(this->isNext("loop"))
-            expression = this->exprLoop();
-        else if(this->isNext("unless"))
-            expression = this->exprUnless();
-        else if(this->isNext("when"))
-            expression = this->exprWhen();
-        else if(this->isNext("func"))
-            expression = this->exprFunctionDecl();
-        else if(this->isNext("["))
-            expression = this->exprArray();
-        else if(this->peek().getType() == TokenType::IDENTIFIER) {
-            expression = std::make_unique<VariableAccessExpression>(
-                std::make_unique<Token>(this->consume(TokenType::IDENTIFIER))
-            );
-
-            while(this->isNext("[")) {
-                Token address = this->consume("[");
-                std::unique_ptr<ASTNode> indexExpr = this->expression();
-
-                this->consume("]");
-                expression = std::make_unique<ArrayAccessExpression>(
-                    std::make_unique<Token>(address),
-                    std::move(expression),
-                    std::move(indexExpr)
-                );
-            }
-        }
-        else expression = this->exprLiteral();
-
-        while(this->isNext("(") || this->isNext("[")) {
-            while(this->isNext("(")) {
-                Token address = this->consume("(");
-                std::vector<std::unique_ptr<ASTNode>> arguments;
-
-                while(!this->isNext(")")) {
-                    if(!arguments.empty())
-                        this->consume(",");
-
-                    arguments.emplace_back(
-                        std::move(this->expression())
-                    );
-                }
-
-                this->consume(")");
-                expression = std::make_unique<FunctionCallExpression>(
-                    std::make_unique<Token>(address),
-                    std::move(expression),
-                    std::move(arguments)
-                );
-            }
-
-            while(this->isNext("[")) {
-                Token address = this->consume("[");
-                std::unique_ptr<ASTNode> indexExpr = this->expression();
-
-                this->consume("]");
-                expression = std::make_unique<ArrayAccessExpression>(
-                    std::make_unique<Token>(address),
-                    std::move(expression),
-                    std::move(indexExpr)
-                );
-            }
-        }
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> exprLogicOr() {
-        std::unique_ptr<ASTNode> expression = this->exprLogicAnd();
-
-        while(this->isNext("||"))
-            expression = std::make_unique<BinaryExpression>(
-                std::make_unique<Token>(
-                    this->consume(TokenType::OPERATOR)
-                ),
-                std::move(expression),
-                "||",
-                std::move(this->exprLogicAnd())
-            );
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> exprLogicAnd() {
-        std::unique_ptr<ASTNode> expression = this->exprBitwiseOr();
-
-        while(this->isNext("&&"))
-            expression = std::make_unique<BinaryExpression>(
-                std::make_unique<Token>(
-                    this->consume(TokenType::OPERATOR)
-                ),
-                std::move(expression),
-                "&&",
-                std::move(this->exprBitwiseOr())
-            );
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> exprBitwiseOr() {
-        std::unique_ptr<ASTNode> expression = this->exprBitwiseXor();
-
-        while(this->isNext("|"))
-            expression = std::make_unique<BinaryExpression>(
-                std::make_unique<Token>(
-                    this->consume(TokenType::OPERATOR)
-                ),
-                std::move(expression),
-                "|",
-                std::move(this->exprBitwiseXor())
-            );
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> exprBitwiseXor() {
-        std::unique_ptr<ASTNode> expression = this->exprBitwiseAnd();
-
-        while(this->isNext("^"))
-            expression = std::make_unique<BinaryExpression>(
-                std::make_unique<Token>(
-                    this->consume(TokenType::OPERATOR)
-                ),
-                std::move(expression),
-                "^",
-                std::move(this->exprBitwiseAnd())
-            );
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> exprBitwiseAnd() {
-        std::unique_ptr<ASTNode> expression = this->exprNilCoalescing();
-
-        while(this->isNext("&"))
-            expression = std::make_unique<BinaryExpression>(
-                std::make_unique<Token>(
-                    this->consume(TokenType::OPERATOR)
-                ),
-                std::move(expression),
-                "&",
-                std::move(this->exprNilCoalescing())
-            );
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> exprNilCoalescing() {
-        std::unique_ptr<ASTNode> expression = this->exprEquality();
-
-        while(this->isNext("?"))
-            expression = std::make_unique<NilCoalescingExpression>(
-                std::make_unique<Token>(
-                    this->consume(TokenType::OPERATOR)
-                ),
-                std::move(expression),
-                std::move(this->exprEquality())
-            );
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> exprEquality() {
-        std::unique_ptr<ASTNode> expression = this->exprComparison();
-
-        while(this->isNext("==") || this->isNext("!=") || this->isNext("=")) {
-            Token op = this->consume(TokenType::OPERATOR);
-            expression = std::make_unique<BinaryExpression>(
-                std::make_unique<Token>(op),
-                std::move(expression),
-                op.getImage(),
-                std::move(this->exprComparison())
-            );
-        }
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> exprComparison() {
-        std::unique_ptr<ASTNode> expression = this->exprShift();
-
-        while(this->isNext("<") ||
-            this->isNext("<=") ||
-            this->isNext(">") ||
-            this->isNext(">=")
-        ) {
-            Token op = this->consume(TokenType::OPERATOR);
-            expression = std::make_unique<BinaryExpression>(
-                std::make_unique<Token>(op),
-                std::move(expression),
-                op.getImage(),
-                std::move(this->exprShift())
-            );
-        }
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> exprShift() {
-        std::unique_ptr<ASTNode> expression = this->exprTerm();
-
-        while(this->isNext("<<") || this->isNext(">>")) {
-            Token op = this->consume(TokenType::OPERATOR);
-            expression = std::make_unique<BinaryExpression>(
-                std::make_unique<Token>(op),
-                std::move(expression),
-                op.getImage(),
-                std::move(this->exprTerm())
-            );
-        }
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> exprTerm() {
-        std::unique_ptr<ASTNode> expression = this->exprFactor();
-
-        while(this->isNext("+") || this->isNext("-")) {
-            Token op = this->consume(TokenType::OPERATOR);
-            expression = std::make_unique<BinaryExpression>(
-                std::make_unique<Token>(op),
-                std::move(expression),
-                op.getImage(),
-                std::move(this->exprFactor())
-            );
-        }
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> exprFactor() {
-        std::unique_ptr<ASTNode> expression = this->exprPrimary();
-
-        while(this->isNext("*") || this->isNext("/") || this->isNext("%")) {
-            Token op = this->consume(TokenType::OPERATOR);
-            expression = std::make_unique<BinaryExpression>(
-                std::make_unique<Token>(op),
-                std::move(expression),
-                op.getImage(),
-                std::move(this->exprPrimary())
-            );
-        }
-
-        return expression;
-    }
-
-    std::unique_ptr<ASTNode> expression() {
-        return this->exprLogicOr();
-    }
-
-    std::unique_ptr<ASTNode> stmtBreak() {
-        Token address = this->consume("break");
-        this->consume(";");
-
-        return std::make_unique<BreakStatement>(
-            std::make_unique<Token>(address)
-        );
-    }
-
-    std::unique_ptr<ASTNode> stmtContinue() {
-        Token address = this->consume("continue");
-        this->consume(";");
-
-        return std::make_unique<ContinueStatement>(
-            std::make_unique<Token>(address)
-        );
-    }
-
-    std::unique_ptr<ASTNode> stmtRet() {
-        Token address = this->consume("ret");
-        std::unique_ptr<ASTNode> expression = this->expression();
-
-        this->consume(";");
-        return std::make_unique<ReturnStatement>(
-            std::make_unique<Token>(address),
-            std::move(expression)
-        );        
-    }
-
-    std::unique_ptr<ASTNode> stmtThrow() {
-        Token address = this->consume("throw");
-        std::unique_ptr<ASTNode> expression = this->expression();
-
-        this->consume(";");
-        return std::make_unique<ThrowStatement>(
-            std::make_unique<Token>(address),
-            std::move(expression)
-        );
-    }
-
-    std::unique_ptr<ASTNode> stmtTest() {
-        Token address = this->consume("test");
-        this->consume("(");
-
-        std::unique_ptr<ASTNode> testName = this->expression();
-        this->consume(")");
-
-        std::unique_ptr<ASTNode> testBody = this->expression();
-        this->consume(";");
-
-        return std::make_unique<TestStatement>(
-            std::make_unique<Token>(address),
-            std::move(testName),
-            std::move(testBody)
-        );
-    }
-
-    std::unique_ptr<ASTNode> statement() {
-        if(this->isNext("break"))
-            return this->stmtBreak();
-        else if(this->isNext("continue"))
-            return this->stmtContinue();
-        else if(this->isNext("ret"))
-            return this->stmtRet();
-        else if(this->isNext("throw"))
-            return this->stmtThrow();
-        else if(this->isNext("test"))
-            return this->stmtTest();
-
-        std::unique_ptr<ASTNode> expr = this->expression();
-        this->consume(";");
-
-        return expr;
-    }
+    const std::vector<std::unique_ptr<ASTNode>>& getGlobalStatements() const;
+    void parse();
 
-    void parse() {
-        while(!this->isAtEnd())
-            this->globalStatements.push_back(this->statement());
-    }
+    static Parser fromFile(const std::string& fileName);
 };
 
 #endif