parser.div

/*
 * Copyright 2025-2026 Yusuf Rençber
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

include "divio", "divstr", "divfile", "divvec", "divmap", "lexer.div", "preprocessor.div" : *;

enum ASTNodeType: i32 {
    ROOT, INLINE_ASM,

    VARIABLE_DECL, CONSTANT_DECL, STATIC_DECL,
    FUNCTION_DECL, CLASS_DECL, ENUM_DECL, TYPE_DECL,
    EXTERN_BLOCK, IMPL_BLOCK, PARAMETER, FIELD, VARIANT,

    IF_STMT, IF_LET_STMT, MATCH_STMT, CASE_STMT, DEFAULT_STMT,
    WHILE_STMT, WHILE_LET_STMT, FOR_STMT, LOOP_STMT, BLOCK_STMT,
    EXPRESSION_STMT, RETURN_STMT, BREAK_STMT, CONTINUE_STMT,

    UNARY_OP, BINARY_OP, ASSIGNMENT, TERNARY, CALL, CAST, NEW, DELETE,
    LITERAL, IDENTIFIER, SCOPE_RESOLUTION, MEMBER_ACCESS, INDEX_ACCESS,
    RANGE_EXPR, AWAIT_EXPR, INITIALIZER_LIST, STRUCT_INIT, OR_PATTERN,

    PRIMITIVE_TYPE, POINTER_TYPE, REFERENCE_TYPE, ARRAY_TYPE, FUNCTION_TYPE
};

func ASTNodeTypeToString(_type: ASTNodeType) -> *const i8 {
    if _type == ASTNodeType::ROOT { ret "ROOT"; }
    else if _type == ASTNodeType::VARIABLE_DECL { ret "VARIABLE_DECL"; }
    else if _type == ASTNodeType::CONSTANT_DECL { ret "CONSTANT_DECL"; }
    else if _type == ASTNodeType::STATIC_DECL { ret "STATIC_DECL"; }
    else if _type == ASTNodeType::FUNCTION_DECL { ret "FUNCTION_DECL"; }
    else if _type == ASTNodeType::CLASS_DECL { ret "CLASS_DECL"; }
    else if _type == ASTNodeType::ENUM_DECL { ret "ENUM_DECL"; }
    else if _type == ASTNodeType::TYPE_DECL { ret "TYPE_DECL"; }
    else if _type == ASTNodeType::EXTERN_BLOCK { ret "EXTERN_BLOCK"; }
    else if _type == ASTNodeType::IMPL_BLOCK { ret "IMPL_BLOCK"; }
    else if _type == ASTNodeType::PARAMETER { ret "PARAMETER"; }
    else if _type == ASTNodeType::FIELD { ret "FIELD"; }
    else if _type == ASTNodeType::VARIANT { ret "VARIANT"; }
    else if _type == ASTNodeType::IF_STMT { ret "IF_STMT"; }
    else if _type == ASTNodeType::IF_LET_STMT { ret "IF_LET_STMT"; }
    else if _type == ASTNodeType::MATCH_STMT { ret "MATCH_STMT"; }
    else if _type == ASTNodeType::CASE_STMT { ret "CASE_STMT"; }
    else if _type == ASTNodeType::DEFAULT_STMT { ret "DEFAULT_STMT"; }
    else if _type == ASTNodeType::WHILE_STMT { ret "WHILE_STMT"; }
    else if _type == ASTNodeType::WHILE_LET_STMT { ret "WHILE_LET_STMT"; }
    else if _type == ASTNodeType::FOR_STMT { ret "FOR_STMT"; }
    else if _type == ASTNodeType::LOOP_STMT { ret "LOOP_STMT"; }
    else if _type == ASTNodeType::BLOCK_STMT { ret "BLOCK_STMT"; }
    else if _type == ASTNodeType::EXPRESSION_STMT { ret "EXPRESSION_STMT"; }
    else if _type == ASTNodeType::RETURN_STMT { ret "RETURN_STMT"; }
    else if _type == ASTNodeType::BREAK_STMT { ret "BREAK_STMT"; }
    else if _type == ASTNodeType::CONTINUE_STMT { ret "CONTINUE_STMT"; }
    else if _type == ASTNodeType::UNARY_OP { ret "UNARY_OP"; }
    else if _type == ASTNodeType::BINARY_OP { ret "BINARY_OP"; }
    else if _type == ASTNodeType::ASSIGNMENT { ret "ASSIGNMENT"; }
    else if _type == ASTNodeType::TERNARY { ret "TERNARY"; }
    else if _type == ASTNodeType::CALL { ret "CALL"; }
    else if _type == ASTNodeType::CAST { ret "CAST"; }
    else if _type == ASTNodeType::NEW { ret "NEW"; }
    else if _type == ASTNodeType::DELETE { ret "DELETE"; }
    else if _type == ASTNodeType::LITERAL { ret "LITERAL"; }
    else if _type == ASTNodeType::IDENTIFIER { ret "IDENTIFIER"; }
    else if _type == ASTNodeType::SCOPE_RESOLUTION { ret "SCOPE_RESOLUTION"; }
    else if _type == ASTNodeType::MEMBER_ACCESS { ret "MEMBER_ACCESS"; }
    else if _type == ASTNodeType::INDEX_ACCESS { ret "INDEX_ACCESS"; }
    else if _type == ASTNodeType::RANGE_EXPR { ret "RANGE_EXPR"; }
    else if _type == ASTNodeType::AWAIT_EXPR { ret "AWAIT_EXPR"; }
    else if _type == ASTNodeType::INITIALIZER_LIST { ret "INITIALIZER_LIST"; }
    else if _type == ASTNodeType::STRUCT_INIT { ret "STRUCT_INIT"; }
    else if _type == ASTNodeType::OR_PATTERN { ret "OR_PATTERN"; }
    else if _type == ASTNodeType::PRIMITIVE_TYPE { ret "PRIMITIVE_TYPE"; }
    else if _type == ASTNodeType::POINTER_TYPE { ret "POINTER_TYPE"; }
    else if _type == ASTNodeType::REFERENCE_TYPE { ret "REFERENCE_TYPE"; }
    else if _type == ASTNodeType::ARRAY_TYPE { ret "ARRAY_TYPE"; }
    else if _type == ASTNodeType::FUNCTION_TYPE { ret "FUNCTION_TYPE"; }
    else { ret "UNKNOWN"; }
}

class ASTNode {
    pub node_type: ASTNodeType,
    pub row: u64, pub column: u64,
    pub file: String
} impl {
    ASTNode(this: &mut ASTNode, _type: ASTNodeType, row: u64, column: u64, file: String) {
        (this.node_type, this.row, this.column, this.file) = (_type, row, column, file);
    }
};

class PrimitiveTypeNode : ASTNode {
    pub name: String,
    pub generic: bool = false,
    pub types: Vector<*const ASTNode>
} impl {
    PrimitiveTypeNode(this: &mut PrimitiveTypeNode, name: String, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::PRIMITIVE_TYPE, row, column, file) {
        this.name = name;
    }
};

class PointerTypeNode : ASTNode {
    pub base_type: *const ASTNode,
    pub mutable: bool = false
} impl {
    PointerTypeNode(this: &mut PointerTypeNode, base_type: *const ASTNode, mutable: bool, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::POINTER_TYPE, row, column, file) {
        (this.base_type, this.mutable) = (base_type, mutable);
    }
};

class ReferenceTypeNode : ASTNode {
    pub base_type: *const ASTNode,
    pub mutable: bool = false
} impl {
    ReferenceTypeNode(this: &mut ReferenceTypeNode, base_type: *const ASTNode, mutable: bool, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::REFERENCE_TYPE, row, column, file) {
        (this.base_type, this.mutable) = (base_type, mutable);
    }
};

class ArrayTypeNode : ASTNode {
    pub element_type: *const ASTNode,
    pub size: *const ASTNode
} impl {
    ArrayTypeNode(this: &mut ArrayTypeNode, element_type: *const ASTNode, size: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::ARRAY_TYPE, row, column, file) {
        (this.element_type, this.size) = (element_type, size);
    }
};

class LiteralNode : ASTNode {
    pub value: String,
    pub literal_type: TokenType
} impl {
    LiteralNode(this: &mut LiteralNode, value: String, literal_type: TokenType, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::LITERAL, row, column, file) {
        (this.value, this.literal_type) = (value, literal_type);
    }
};

class IdentifierNode : ASTNode {
    pub name: String
} impl {
    IdentifierNode(this: &mut IdentifierNode, name: String, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::IDENTIFIER, row, column, file) {
        this.name = name;
    }
};

class ScopeResolutionNode : ASTNode {
    pub scope: *const ASTNode,
    pub identifier: *const IdentifierNode
} impl {
    ScopeResolutionNode(this: &mut ScopeResolutionNode, scope: *const ASTNode, identifier: *const IdentifierNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::SCOPE_RESOLUTION, row, column, file) {
        (this.scope, this.identifier) = (scope, identifier);
    }
};

class BinaryOpNode : ASTNode {
    pub left: *const ASTNode,
    pub right: *const ASTNode,
    pub operator: TokenType
} impl {
    BinaryOpNode(this: &mut BinaryOpNode, left: *const ASTNode, right: *const ASTNode, operator: TokenType, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::BINARY_OP, row, column, file) {
        (this.left, this.right, this.operator) = (left, right, operator);
    }
};

class UnaryOpNode : ASTNode {
    pub operand: *const ASTNode,
    pub operator: TokenType,
    pub mutable: bool = false
} impl {
    UnaryOpNode(this: &mut UnaryOpNode, operand: *const ASTNode, operator: TokenType, mutable: bool, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::UNARY_OP, row, column, file) {
        (this.operand, this.operator, this.mutable) = (operand, operator, mutable);
    }
};

class TernaryNode : ASTNode {
    pub condition: *const ASTNode,
    pub then_expr: *const ASTNode,
    pub else_expr: *const ASTNode
} impl {
    TernaryNode(this: &mut TernaryNode, condition: *const ASTNode, then_expr: *const ASTNode, else_expr: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::TERNARY, row, column, file) {
        (this.condition, this.then_expr, this.else_expr) = (condition, then_expr, else_expr);
    }
};

class CallNode : ASTNode {
    pub expression: *const ASTNode,
    pub arguments: Vector<*const ASTNode>
} impl {
    CallNode(this: &mut CallNode, expression: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::CALL, row, column, file) {
        this.expression = expression;
    }
};

class MemberAccessNode : ASTNode {
    pub expression: *const ASTNode,
    pub member: String,
    pub arrow: bool = false
} impl {
    MemberAccessNode(this: &mut MemberAccessNode, expression: *const ASTNode, arrow: bool, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::MEMBER_ACCESS, row, column, file) {
        (this.expression, this.arrow) = (expression, arrow);
    }
};

class IndexAccessNode : ASTNode {
    pub expression: *const ASTNode,
    pub index: *const ASTNode
} impl {
    IndexAccessNode(this: &mut IndexAccessNode, expression: *const ASTNode, index: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::INDEX_ACCESS, row, column, file) {
        (this.expression, this.index) = (expression, index);
    }
};

class CastNode : ASTNode {
    pub expression: *const ASTNode,
    pub target_type: *const ASTNode
} impl {
    CastNode(this: &mut CastNode, expression: *const ASTNode, target_type: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::CAST, row, column, file) {
        (this.expression, this.target_type) = (expression, target_type);
    }
};

class InitializerListNode : ASTNode {
    pub expressions: Vector<*const ASTNode>
} impl {
    InitializerListNode(this: &mut InitializerListNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::INITIALIZER_LIST, row, column, file) {}
};

class NewNode : ASTNode {
    pub _type: *const ASTNode,
    pub arguments: Vector<*const ASTNode>,
    pub size: *const ASTNode = null
} impl {
    NewNode(this: &mut NewNode, _type: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::NEW, row, column, file) {
        this._type = _type;
    }
};

class DeleteNode : ASTNode {
    pub expression: *const ASTNode,
    pub array: bool = false
} impl {
    DeleteNode(this: &mut DeleteNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::DELETE, row, column, file) {}
};

class ExpressionStmtNode : ASTNode {
    pub expression: *const ASTNode
} impl {
    ExpressionStmtNode(this: &mut ExpressionStmtNode, expression: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::EXPRESSION_STMT, row, column, file) {
        this.expression = expression;
    }
};

class VariableDeclNode : ASTNode {
    pub name: String,
    pub _type: *const ASTNode,
    pub initializer: *const ASTNode,
    pub mutable: bool = false,
    pub next: *const VariableDeclNode = null
} impl {
    VariableDeclNode(this: &mut VariableDeclNode, name: String, _type: *const ASTNode, initializer: *const ASTNode, mutable: bool, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::VARIABLE_DECL, row, column, file) {
        (this.name, this._type, this.initializer, this.mutable) = (name, _type, initializer, mutable);
    }
};

class ConstantDeclNode : ASTNode {
    pub name: String,
    pub _type: *const ASTNode,
    pub initializer: *const ASTNode
} impl {
    ConstantDeclNode(this: &mut ConstantDeclNode, name: String, _type: *const ASTNode, initializer: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::CONSTANT_DECL, row, column, file) {
        (this.name, this._type, this.initializer) = (name, _type, initializer);
    }
};

class StaticDeclNode : ASTNode {
    pub name: String,
    pub _type: *const ASTNode,
    pub initializer: *const ASTNode,
    pub mutable: bool
} impl {
    StaticDeclNode(this: &mut StaticDeclNode, name: String, _type: *const ASTNode, initializer: *const ASTNode, mutable: bool, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::STATIC_DECL, row, column, file) {
        (this.name, this._type, this.initializer, this.mutable) = (name, _type, initializer, mutable);
    }
};

class AssignmentNode : ASTNode {
    pub left: *const ASTNode,
    pub right: *const ASTNode,
    pub operator: TokenType,
    pub next: *const AssignmentNode = null
} impl {
    AssignmentNode(this: &mut AssignmentNode, left: *const ASTNode, right: *const ASTNode, operator: TokenType, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::ASSIGNMENT, row, column, file) {
        (this.left, this.right, this.operator) = (left, right, operator);
    }
};

class IfStmtNode : ASTNode {
    pub condition: *const ASTNode,
    pub then_stmt: *const ASTNode,
    pub else_stmt: *const ASTNode
} impl {
    IfStmtNode(this: &mut IfStmtNode, condition: *const ASTNode, then_stmt: *const ASTNode, else_stmt: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::IF_STMT, row, column, file) {
        (this.condition, this.then_stmt, this.else_stmt) = (condition, then_stmt, else_stmt);
    }
};

class WhileStmtNode : ASTNode {
    pub condition: *const ASTNode,
    pub loop_stmt: *const ASTNode,
    pub else_stmt: *const ASTNode
} impl {
    WhileStmtNode(this: &mut WhileStmtNode, condition: *const ASTNode, loop_stmt: *const ASTNode, else_stmt: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::WHILE_STMT, row, column, file) {
        (this.condition, this.loop_stmt, this.else_stmt) = (condition, loop_stmt, else_stmt);
    }
};

class LoopStmtNode : ASTNode {
    pub loop_stmt: *const ASTNode
} impl {
    LoopStmtNode(this: &mut LoopStmtNode, loop_stmt: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::LOOP_STMT, row, column, file) {
        this.loop_stmt = loop_stmt;
    }
};

class ReturnStmtNode : ASTNode {
    pub expression: *const ASTNode
} impl {
    ReturnStmtNode(this: &mut ReturnStmtNode, expression: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::RETURN_STMT, row, column, file) {
        this.expression = expression;
    }
};

class BreakStmtNode : ASTNode {} impl {
    BreakStmtNode(this: &mut BreakStmtNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::BREAK_STMT, row, column, file) {}
};

class ContinueStmtNode : ASTNode {} impl {
    ContinueStmtNode(this: &mut ContinueStmtNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::CONTINUE_STMT, row, column, file) {}
};

class BlockStmtNode : ASTNode {
    pub statements: Vector<*const ASTNode>
} impl {
    BlockStmtNode(this: &mut BlockStmtNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::BLOCK_STMT, row, column, file) {}
};

class ParameterNode : ASTNode {
    pub name: String,
    pub param_type: *const ASTNode,
    pub mutable: bool = false
} impl {
    ParameterNode(this: &mut ParameterNode, name: String, param_type: *const ASTNode, mutable: bool, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::PARAMETER, row, column, file) {
        (this.name, this.param_type, this.mutable) = (name, param_type, mutable);
    }
};

class FunctionTypeNode : ASTNode {
    pub parameters: Vector<*const ParameterNode>,
    pub return_type: *const ASTNode,
    pub var_arg: bool = false
} impl {
    FunctionTypeNode(this: &mut FunctionTypeNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::FUNCTION_TYPE, row, column, file) {}
};

class FunctionDeclNode : ASTNode {
    pub name: String,
    pub _type: *const FunctionTypeNode,
    pub body: *const BlockStmtNode = null,
    pub generic: bool = false,
    pub types: Vector<String>,
    pub constructors: Vector<*const CallNode>,
    pub is_async: bool = false
} impl {
    FunctionDeclNode(this: &mut FunctionDeclNode, name: String, _type: *const FunctionTypeNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::FUNCTION_DECL, row, column, file) {
        (this.name, this._type) = (name, _type);
    }
};

class AwaitExprNode : ASTNode {
    pub expression: *const ASTNode
} impl {
    AwaitExprNode(this: &mut AwaitExprNode, expression: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::AWAIT_EXPR, row, column, file) {
        this.expression = expression;
    }
};

class TypeDeclNode : ASTNode {
    pub name: String,
    pub _type: *const ASTNode
} impl {
    TypeDeclNode(this: &mut TypeDeclNode, name: String, _type: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::TYPE_DECL, row, column, file) {
        (this.name, this._type) = (name, _type);
    }
};

class FieldNode : ASTNode {
    pub name: String,
    pub field_type: *const ASTNode,
    pub initializer: *const ASTNode
} impl {
    FieldNode(this: &mut FieldNode, name: String, field_type: *const ASTNode, initializer: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::FIELD, row, column, file) {
        (this.name, this.field_type, this.initializer) = (name, field_type, initializer);
    }
};

class ClassDeclNode : ASTNode {
    pub name: String,
    pub fields: Vector<Pair<TokenType, *const FieldNode>>,
    pub methods: Vector<Pair<TokenType, *const FunctionDeclNode>>,
    pub constructors: Vector<*const FunctionDeclNode>,
    pub destructor: *const FunctionDeclNode = null,
    pub parents: Vector<*const ASTNode>,
    pub generic: bool = false,
    pub types: Vector<String>
} impl {
    ClassDeclNode(this: &mut ClassDeclNode, name: String, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::CLASS_DECL, row, column, file) {
        this.name = name;
    }
};

class VariantNode : ASTNode {
    pub name: String,
    pub types: Vector<*const ASTNode>,
    pub field_names: Vector<String>,
    pub value: *const ASTNode = null
} impl {
    VariantNode(this: &mut VariantNode, name: String, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::VARIANT, row, column, file) {
        this.name = name;
    }
};

class EnumDeclNode : ASTNode {
    pub name: String,
    pub variants: Vector<*const VariantNode>,
    pub methods: Vector<Pair<TokenType, *const FunctionDeclNode>>,
    pub underlying_type: *const ASTNode,
    pub generic: bool,
    pub types: Vector<String>
} impl {
    EnumDeclNode(this: &mut EnumDeclNode, name: String, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::ENUM_DECL, row, column, file) {
        (this.name, this.underlying_type, this.generic) = (name, null, false);
    }
};

class CaseStmtNode : ASTNode {
    pub pattern: *const ASTNode,
    pub body: *const ASTNode,
    pub guard: *const ASTNode
} impl {
    CaseStmtNode(this: &mut CaseStmtNode, pattern: *const ASTNode, body: *const ASTNode, guard: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::CASE_STMT, row, column, file) {
        (this.pattern, this.body, this.guard) = (pattern, body, guard);
    }
};

class DefaultStmtNode : ASTNode {
    pub body: *const ASTNode
} impl {
    DefaultStmtNode(this: &mut DefaultStmtNode, body: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::DEFAULT_STMT, row, column, file) {
        this.body = body;
    }
};

class MatchStmtNode : ASTNode {
    pub expression: *const ASTNode,
    pub cases: Vector<*const CaseStmtNode>,
    pub default_case: *const DefaultStmtNode
} impl {
    MatchStmtNode(this: &mut MatchStmtNode, expression: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::MATCH_STMT, row, column, file) {
        (this.expression, this.default_case) = (expression, null);
    }
};

class StructInitNode : ASTNode {
    pub expression: *const ASTNode,
    pub field_names: Vector<String>,
    pub field_values: Vector<*const ASTNode>
} impl {
    StructInitNode(this: &mut StructInitNode, expression: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::STRUCT_INIT, row, column, file) {
        this.expression = expression;
    }
};

class OrPatternNode : ASTNode {
    pub left: *const ASTNode,
    pub right: *const ASTNode
} impl {
    OrPatternNode(this: &mut OrPatternNode, left: *const ASTNode, right: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::OR_PATTERN, row, column, file) {
        (this.left, this.right) = (left, right);
    }
};

class IfLetStmtNode : ASTNode {
    pub pattern: *const ASTNode,
    pub expression: *const ASTNode,
    pub then_stmt: *const ASTNode,
    pub else_stmt: *const ASTNode = null
} impl {
    IfLetStmtNode(this: &mut IfLetStmtNode, pattern: *const ASTNode, expression: *const ASTNode, then_stmt: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::IF_LET_STMT, row, column, file) {
        (this.pattern, this.expression, this.then_stmt) = (pattern, expression, then_stmt);
    }
};

class WhileLetStmtNode : ASTNode {
    pub pattern: *const ASTNode,
    pub expression: *const ASTNode,
    pub loop_stmt: *const ASTNode
} impl {
    WhileLetStmtNode(this: &mut WhileLetStmtNode, pattern: *const ASTNode, expression: *const ASTNode, loop_stmt: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::WHILE_LET_STMT, row, column, file) {
        (this.pattern, this.expression, this.loop_stmt) = (pattern, expression, loop_stmt);
    }
};

class RangeExprNode : ASTNode {
    pub start: *const ASTNode,
    pub end: *const ASTNode,
    pub inclusive: bool = false
} impl {
    RangeExprNode(this: &mut RangeExprNode, start: *const ASTNode, end: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::RANGE_EXPR, row, column, file) {
        (this.start, this.end) = (start, end);
    }
};

class ForStmtNode : ASTNode {
    pub variable: String,
    pub iterable: *const ASTNode,
    pub loop_stmt: *const ASTNode
} impl {
    ForStmtNode(this: &mut ForStmtNode, variable: String, iterable: *const ASTNode, loop_stmt: *const ASTNode, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::FOR_STMT, row, column, file) {
        (this.variable, this.iterable, this.loop_stmt) = (variable, iterable, loop_stmt);
    }
};

class ExternBlockNode : ASTNode {
    pub linkage: String,
    pub declarations: Vector<*const ASTNode>
} impl {
    ExternBlockNode(this: &mut ExternBlockNode, linkage: String, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::EXTERN_BLOCK, row, column, file) {
        this.linkage = linkage;
    }
};

class InlineAsmNode : ASTNode {
    pub _volatile: bool, pub code: String,
    pub inputs: Vector<Pair<String, *const ASTNode>>,
    pub outputs: Vector<Pair<String, *const ASTNode>>,
    pub clobbers: Vector<String>
} impl {
    InlineAsmNode(this: &mut InlineAsmNode, _volatile: bool, row: u64, column: u64, file: String) : ASTNode(ASTNodeType::INLINE_ASM, row, column, file) {
        this._volatile = _volatile;
    }
};

class RootNode : ASTNode {
    pub declarations: Vector<*const ASTNode>
} impl {
    RootNode(this: &mut RootNode) : ASTNode(ASTNodeType::ROOT, 1u64, 1u64, String("<root>")) {}
};

class Parser {
    priv root: *mut RootNode,
    priv types: Vector<String>,
    pub defines: Vector<String>,
    pub include_paths: Vector<String>,
    priv included_paths: Vector<String>,
    priv file: String, priv index: u64,
    priv tokens: Vector<Token>
} impl {
    priv Current(this: &Parser) -> Token {
        if this.index >= this.tokens.Size() {
            ret this.tokens[this.tokens.Size() - 1u64];
        } else {
            ret this.tokens[this.index];
        }
    }

    priv Peek(this: &Parser, offset: u64) -> Token {
        let index: u64 = this.index + offset;

        if index >= this.tokens.Size() {
            ret this.tokens[this.tokens.Size() - 1u64];
        } else {
            ret this.tokens[index];
        }
    }

    priv Advance(this: &mut Parser) -> Token {
        let token: Token = this.Current();

        if this.index < this.tokens.Size() {
            this.index += 1u64;
        } ret token;
    }

    priv Match(this: &mut Parser, _type: TokenType) -> bool {
        if this.Current()._type == _type {
            this.Advance();
            ret true;
        } else {
            ret false;
        }
    }

    priv Expect(this: &mut Parser, _type: TokenType) -> Token {
        let token: Token = this.Current();

        if token._type == _type {
            ret this.Advance();
        }

        Logger::Log(this.file, String("Expected '") + TokenTypeToString(_type) + "' but got '" + TokenTypeToString(token._type) + "'.", token, LogSeverity::Error);

        let mut error: Token;
        (error._type, error.row, error.column) = (TokenType::UNKNOWN, token.row, token.column);
        ret error;
    }

    priv Expect2(this: &mut Parser, _type: TokenType) -> bool {
        let token: Token = this.Current();

        if token._type == _type {
            this.Advance();
            ret true;
        }

        Logger::Log(this.file, String("Expected '") + TokenTypeToString(_type) + "' but got '" + TokenTypeToString(token._type) + "'.", token, LogSeverity::Error);
        ret false;
    }

    priv GetBinaryOpPrecedence(this: &Parser, _type: TokenType) -> i32 {
        if _type == TokenType::OR { ret 1i32; }
        else if _type == TokenType::AND { ret 2i32; }
        else if _type == TokenType::BITWISE_OR { ret 3i32; }
        else if _type == TokenType::BITWISE_XOR { ret 4i32; }
        else if _type == TokenType::BITWISE_AND { ret 5i32; }
        else if _type == TokenType::EQUAL || _type == TokenType::NOT_EQUAL { ret 6i32; }
        else if _type == TokenType::LESS || _type == TokenType::LESS_EQUAL || _type == TokenType::GREATER || _type == TokenType::GREATER_EQUAL { ret 7i32; }
        else if _type == TokenType::LSHIFT || _type == TokenType::RSHIFT { ret 8i32; }
        else if _type == TokenType::PLUS || _type == TokenType::MINUS { ret 9i32; }
        else if _type == TokenType::MUL || _type == TokenType::DIV || _type == TokenType::MOD { ret 10i32; }
        else if _type == TokenType::AS { ret 11i32; }
        else { ret -1i32; }
    }

    priv IsBinaryOperator(this: &Parser, _type: TokenType) -> bool {
        let precedence: i32 = this.GetBinaryOpPrecedence(_type);
        ret precedence >= 0i32 && precedence != 11i32;
    }

    priv IsUnaryOperator(this: &Parser, _type: TokenType) -> bool {
        ret _type == TokenType::NOT || _type == TokenType::MINUS || _type == TokenType::BITWISE_AND || _type == TokenType::MUL;
    }

    priv IsStructInit(this: &Parser, node_type: ASTNodeType) -> bool {
        let after_brace: Token = this.Peek(1u64);

        if node_type == ASTNodeType::SCOPE_RESOLUTION {
            if after_brace._type == TokenType::RBRACE { ret true; }
            if after_brace._type == TokenType::TWO_DOT { ret true; }
        }

        if after_brace._type == TokenType::IDENTIFIER {
            let after_name: Token = this.Peek(2u64);
            if after_name._type == TokenType::COLON { ret true; }

            if node_type == ASTNodeType::SCOPE_RESOLUTION {
                ret after_name._type == TokenType::COMMA || after_name._type == TokenType::RBRACE;
            }
        } ret false;
    }

    priv IsAssignmentOperator(this: &Parser, _type: TokenType) -> bool {
        ret _type == TokenType::ASSIGN || _type == TokenType::PLUS_ASSIGN || _type == TokenType::MINUS_ASSIGN || _type == TokenType::MUL_ASSIGN || _type == TokenType::DIV_ASSIGN || _type == TokenType::MOD_ASSIGN
           || _type == TokenType::LSHIFT_ASSIGN || _type == TokenType::RSHIFT_ASSIGN || _type == TokenType::AND_ASSIGN || _type == TokenType::OR_ASSIGN || _type == TokenType::XOR_ASSIGN;
    }

    priv ParsePrimary(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Current();

        if token._type == TokenType::INTEGER || token._type == TokenType::FLOAT || token._type == TokenType::STRING || token._type == TokenType::CHAR || token._type == TokenType::TRUE || token._type == TokenType::FALSE || token._type == TokenType::NULL {
            this.Advance();
            ret new LiteralNode(token.value, token._type, token.row, token.column, this.file) as *const ASTNode;
        } else if token._type == TokenType::IDENTIFIER || token._type == TokenType::OPERATOR || token._type == TokenType::DOUBLE_COLON {
            let mut node: *const ASTNode = null;

            if token._type != TokenType::DOUBLE_COLON {
                if this.types.Index(token.value) != -1i64 && this.Peek(1u64)._type != TokenType::DOUBLE_COLON {
                    node = this.ParseType();
                    if node == null { ret null; }
                } else {
                    if this.Match(TokenType::OPERATOR) {
                        let mut identifier: String = "op";

                        while this.Current()._type != TokenType::LPAREN && this.Current()._type != TokenType::LESS {
                            identifier += this.Current().value;
                            this.Advance();
                        }

                        node = new IdentifierNode(identifier, token.row, token.column, this.file) as *const ASTNode;
                    } else {
                        let identifier: Token = this.Expect(TokenType::IDENTIFIER);
                        if identifier._type == TokenType::UNKNOWN { ret null; }
                        node = new IdentifierNode(identifier.value, token.row, token.column, this.file) as *const ASTNode;
                    }
                }
            }

            while this.Match(TokenType::DOUBLE_COLON) {
                let mut identifier: *const IdentifierNode = null;

                if this.Match(TokenType::OPERATOR) {
                    let mut _identifier: String = "op";

                    while this.Current()._type != TokenType::LPAREN && this.Current()._type != TokenType::LESS {
                        _identifier += this.Current().value;
                        this.Advance();
                    }

                    identifier = new IdentifierNode(_identifier, token.row, token.column, this.file);
                } else {
                    let _identifier: Token = this.Expect(TokenType::IDENTIFIER);
                    if _identifier._type == TokenType::UNKNOWN { ret null; }
                    identifier = new IdentifierNode(_identifier.value, token.row, token.column, this.file);
                } node = new ScopeResolutionNode(node, identifier, token.row, token.column, this.file) as *const ASTNode;
            } ret node;
        } else if token._type == TokenType::LBRACE {
            this.Advance();
            let initializer_list: *mut InitializerListNode = new InitializerListNode(token.row, token.column, this.file);

            if !this.Match(TokenType::RBRACE) {
                let expression: *const ASTNode = this.ParseExpression();
                if expression == null { ret null; }
                initializer_list->expressions.PushBack(expression);

                while this.Match(TokenType::COMMA) {
                    let expression: *const ASTNode = this.ParseExpression();
                    if expression == null { ret null; }
                    initializer_list->expressions.PushBack(expression);
                }

                if !this.Expect2(TokenType::RBRACE) { ret null; }
            } ret initializer_list as *const ASTNode;
        } else if token._type == TokenType::LPAREN {
            this.Advance();
            let expression: *const ASTNode = this.ParseExpression();
            if expression == null || !this.Expect2(TokenType::RPAREN) { ret null; }
            ret expression;
        } else {
            this.Advance();
            Logger::Log(this.file, String("Unexpected token '") + token.value + "'.", token, LogSeverity::Error);
            ret null;
        }
    }

    priv ParsePostfix(this: &mut Parser) -> *const ASTNode {
        let mut expression: *const ASTNode = this.ParsePrimary();
        if expression == null { ret null; }

        loop {
            let token: Token = this.Current();

            if token._type == TokenType::LPAREN {
                this.Advance();
                let call: *mut CallNode = new CallNode(expression, token.row, token.column, this.file);

                if !this.Match(TokenType::RPAREN) {
                    let expression: *const ASTNode = this.ParseExpression();
                    if expression == null { ret null; }
                    call->arguments.PushBack(expression);

                    while this.Match(TokenType::COMMA) {
                        let expression: *const ASTNode = this.ParseExpression();
                        if expression == null { ret null; }
                        call->arguments.PushBack(expression);
                    }

                    if !this.Expect2(TokenType::RPAREN) { ret null; }
                } expression = call as *const ASTNode;
            } else if token._type == TokenType::DOT || token._type == TokenType::ARROW {
                this.Advance();
                let member_access: *mut MemberAccessNode = new MemberAccessNode(expression, token._type == TokenType::ARROW, token.row, token.column, this.file);

                if this.Match(TokenType::OPERATOR) {
                    member_access->member += "op";

                    while this.Current()._type != TokenType::LPAREN && this.Current()._type != TokenType::LESS {
                        member_access->member += this.Current().value;
                        this.Advance();
                    }
                } else {
                    let identifier: Token = this.Expect(TokenType::IDENTIFIER);
                    if identifier._type == TokenType::UNKNOWN { ret null; }
                    member_access->member += identifier.value;
                } expression = member_access as *const ASTNode;
            } else if token._type == TokenType::LBRACKET {
                this.Advance();
                let _expression: *const ASTNode = this.ParseExpression();
                if _expression == null { ret null; }
                let index_access: *const IndexAccessNode = new IndexAccessNode(expression, _expression, token.row, token.column, this.file);
                if !this.Expect2(TokenType::RBRACKET) { ret null; }
                expression = index_access as *const ASTNode;
            } else if token._type == TokenType::LBRACE && (expression->node_type == ASTNodeType::SCOPE_RESOLUTION || expression->node_type == ASTNodeType::IDENTIFIER) && this.IsStructInit(expression->node_type) {
                this.Advance();
                let struct_init: *mut StructInitNode = new StructInitNode(expression, token.row, token.column, this.file);

                while this.Current()._type != TokenType::RBRACE && this.Current()._type != TokenType::EOF {
                    if this.Current()._type == TokenType::TWO_DOT {
                        this.Advance();
                        break;
                    }

                    let field_name: Token = this.Expect(TokenType::IDENTIFIER);
                    if field_name._type == TokenType::UNKNOWN { ret null; }

                    if this.Match(TokenType::COLON) {
                        let expression: *const ASTNode = this.ParseExpression();
                        if expression == null { ret null; }
                        struct_init->field_values.PushBack(expression);
                    } else {
                        struct_init->field_values.PushBack(new IdentifierNode(field_name.value, field_name.row, field_name.column, this.file) as *const ASTNode);
                    }

                    struct_init->field_names.PushBack(field_name.value);
                    if !this.Match(TokenType::COMMA) { break; }
                }

                if !this.Expect2(TokenType::RBRACE) { ret null; }
                expression = struct_init as *const ASTNode;
            } else {
                break;
            }
        } ret expression;
    }

    priv ParseUnary(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Current();
        let mut mutable: bool = false;

        if this.IsUnaryOperator(token._type) {
            this.Advance();

            if token._type == TokenType::BITWISE_AND {
                mutable = this.Match(TokenType::MUT);
            }

            let expression: *const ASTNode = this.ParseUnary();
            if expression == null { ret null; }
            ret new UnaryOpNode(expression, token._type, mutable, token.row, token.column, this.file) as *const ASTNode;
        } else if token._type == TokenType::NEW {
            this.Advance();
            let _type: *const ASTNode = this.ParseType();
            if _type == null { ret null; }
            let _new: *mut NewNode = new NewNode(_type, token.row, token.column, this.file);

            if this.Match(TokenType::LBRACKET) {
                _new->size = this.ParseExpression();

                if _new->size == null || !this.Expect2(TokenType::RBRACKET) {
                    ret null;
                }
            } else if this.Match(TokenType::LPAREN) {
                if !this.Match(TokenType::RPAREN) {
                    let argument: *const ASTNode = this.ParseExpression();
                    if argument == null { ret null; }
                    _new->arguments.PushBack(argument);

                    while this.Match(TokenType::COMMA) {
                        let argument: *const ASTNode = this.ParseExpression();
                        if argument == null { ret null; }
                        _new->arguments.PushBack(argument);
                    }

                    if !this.Expect2(TokenType::RPAREN) { ret null; }
                }
            } ret _new as *const ASTNode;
        } else if token._type == TokenType::DELETE {
            this.Advance();
            let delete: *mut DeleteNode = new DeleteNode(token.row, token.column, this.file);

            if this.Match(TokenType::LBRACKET) {
                if !this.Expect2(TokenType::RBRACKET) { ret null; }
                delete->array = true;
            }

            delete->expression = this.ParseExpression();
            if delete->expression == null { ret null; }
            ret delete as *const ASTNode;
        } else if token._type == TokenType::AWAIT {
            this.Advance();
            let expression: *const ASTNode = this.ParseUnary();
            if expression == null { ret null; }
            ret new AwaitExprNode(expression, token.row, token.column, this.file) as *const ASTNode;
        } else {
            ret this.ParsePostfix();
        }
    }

    priv ParseBinaryExpression(this: &mut Parser, min_precedence: i32) -> *const ASTNode {
        let mut left: *const ASTNode = this.ParseUnary();
        if left == null { ret null; }

        loop {
            let mut token: Token = this.Current();

            if this.Peek(1u64)._type == token._type {
                if token._type == TokenType::GREATER {
                    token._type = TokenType::RSHIFT;
                    this.Advance();
                }

                if token._type == TokenType::LESS {
                    token._type = TokenType::LSHIFT;
                    this.Advance();
                }
            }

            let precedence: i32 = this.GetBinaryOpPrecedence(token._type);
            if precedence < min_precedence { break; }
            this.Advance();

            if token._type == TokenType::AS {
                let _type: *const ASTNode = this.ParseType();
                if _type == null { ret null; }
                left = new CastNode(left, _type, token.row, token.column, this.file) as *const ASTNode;
            } else {
                let right: *const ASTNode = this.ParseBinaryExpression(precedence + 1i32);
                if right == null { ret null; }
                left = new BinaryOpNode(left, right, token._type, token.row, token.column, this.file) as *const ASTNode;
            }
        } ret left;
    }

    priv ParseExpression(this: &mut Parser) -> *const ASTNode {
        let mut condition: *const ASTNode = this.ParseBinaryExpression(0i32);
        if condition == null { ret null; }
        let token: Token = this.Current();

        if token._type == TokenType::QUESTION_MARK {
            this.Advance();
            let then_expr: *const ASTNode = this.ParseExpression();
            if then_expr == null || !this.Expect2(TokenType::COLON) { ret null; }
            let else_expr: *const ASTNode = this.ParseExpression();
            if else_expr == null { ret null; }
            condition = new TernaryNode(condition, then_expr, else_expr, token.row, token.column, this.file) as *const ASTNode;
        } ret condition;
    }

    priv ParseType(this: &mut Parser) -> *const ASTNode {
        let mut references: Vector<bool>;

        if this.Match(TokenType::BITWISE_AND) {
            references.PushBack(this.Match(TokenType::MUT));
        }

        let mut pointers: Vector<bool>;

        while this.Match(TokenType::MUL) {
            if this.Match(TokenType::MUT) {
                pointers.PushBack(true);
            } else {
                if !this.Expect2(TokenType::CONST) { ret null; }
                pointers.PushBack(false);
            }
        }

        let token: Token = this.Current();
        let mut node: *const ASTNode = null;

        if this.Match(TokenType::FUNC) {
            if !this.Expect2(TokenType::LPAREN) { ret null; }
            let func_type: *mut FunctionTypeNode = new FunctionTypeNode(token.row, token.column, this.file);

            if this.Current()._type != TokenType::RPAREN {
                func_type->var_arg = this.Match(TokenType::THREE_DOT);

                if !func_type->var_arg {
                    let param: *const ParameterNode = this.ParseParameter();
                    if param == null { ret null; }
                    func_type->parameters.PushBack(param);

                    while this.Match(TokenType::COMMA) {
                        func_type->var_arg = this.Match(TokenType::THREE_DOT);
                        if func_type->var_arg { break; }

                        let param: *const ParameterNode = this.ParseParameter();
                        if param == null { ret null; }
                        func_type->parameters.PushBack(param);
                    }
                }
            }

            if !this.Expect2(TokenType::RPAREN) { ret null; }

            if this.Match(TokenType::ARROW) {
                func_type->return_type = this.ParseType();
                if func_type->return_type == null { ret null; }
            } else {
                func_type->return_type = new PrimitiveTypeNode({ "void" } as String, token.row, token.column, this.file) as *const ASTNode;
            } node = func_type as *const ASTNode;
        } else {
            if token._type != TokenType::IDENTIFIER {
                Logger::Log(this.file, "Expected type name.", token, LogSeverity::Error);
                ret null;
            }

            let primitive: *mut PrimitiveTypeNode = new PrimitiveTypeNode(token.value, token.row, token.column, this.file);
            this.Advance();

            if this.Match(TokenType::LESS) {
                let _type: *const ASTNode = this.ParseType();
                if _type == null { ret null; }
                primitive->types.PushBack(_type);

                while this.Match(TokenType::COMMA) {
                    let _type: *const ASTNode = this.ParseType();
                    if _type == null { ret null; }
                    primitive->types.PushBack(_type);
                }

                if !this.Expect2(TokenType::GREATER) { ret null; }
                primitive->generic = true;
            } node = primitive as *const ASTNode;
        }

        let mut index: u64 = pointers.Size();

        while 0u64 < index {
            node = new PointerTypeNode(node, pointers[index - 1u64], token.row, token.column, this.file) as *const ASTNode;
            index -= 1u64;
        }

        if !references.Empty() {
            node = new ReferenceTypeNode(node, references[0u64], token.row, token.column, this.file) as *const ASTNode;
        } ret node;
    }

    priv ParseStatement(this: &mut Parser, expression: bool) -> *const ASTNode {
        let token: Token = this.Current();

        if token._type == TokenType::LET && !expression {
            ret this.ParseVariableDeclaration();
        } else if token._type == TokenType::IF && !expression {
            ret this.ParseIfStatement();
        } else if token._type == TokenType::WHILE && !expression {
            ret this.ParseWhileStatement();
        } else if token._type == TokenType::FOR && !expression {
            ret this.ParseForStatement();
        } else if token._type == TokenType::LOOP && !expression {
            ret this.ParseLoopStatement();
        } else if token._type == TokenType::MATCH && !expression {
            ret this.ParseMatchStatement();
        } else if token._type == TokenType::RETURN {
            ret this.ParseReturnStatement(expression);
        } else if token._type == TokenType::BREAK {
            ret this.ParseBreakStatement(expression);
        } else if token._type == TokenType::CONTINUE {
            ret this.ParseContinueStatement(expression);
        } else if token._type == TokenType::ASSEMBLY || token._type == TokenType::VOLATILE {
            ret this.ParseInlineAsm();
        } else {
            let index: u64 = this.index;

            if this.Match(TokenType::LPAREN) {
                let mut current: *mut AssignmentNode = null;
                let mut root: *const AssignmentNode = null;

                while root == null || this.Match(TokenType::COMMA) {
                    let _expression: *const ASTNode = this.ParseExpression();
                    if _expression == null { ret null; }
                    let assignment: *const AssignmentNode = new AssignmentNode(_expression, null, TokenType::ASSIGN, token.row, token.column, this.file);

                    if root != null {
                        current->next = assignment;
                    } else {
                        root = assignment;
                    } current = assignment;
                }

                if root->next != null {
                    if !this.Expect2(TokenType::RPAREN) { ret null; }
                    if !this.Expect2(TokenType::ASSIGN) { ret null; }
                    if !this.Expect2(TokenType::LPAREN) { ret null; }
                    current = root;

                    while current != null {
                        current->right = this.ParseExpression();
                        if current->right == null { ret null; }

                        if current->next != null {
                            if !this.Expect2(TokenType::COMMA) { ret null; }
                        } current = current->next;
                    }

                    if !this.Expect2(TokenType::RPAREN) { ret null; }
                    if !this.Expect2(TokenType::SEMICOLON) { ret null; }
                    ret root as *const ASTNode;
                } else {
                    this.index = index;
                }
            }

            let left: *const ASTNode = this.ParseExpression();

            if this.IsAssignmentOperator(this.Current()._type) {
                let token: Token = this.Advance();
                let right: *const ASTNode = this.ParseExpression();
                if right == null { ret null; }
                let assignment: *const AssignmentNode = new AssignmentNode(left, right, token._type, token.row, token.column, this.file);

                if !expression {
                    if !this.Expect2(TokenType::SEMICOLON) { ret null; }
                } ret assignment as *const ASTNode;
            } else {
                if !expression {
                    if !this.Expect2(TokenType::SEMICOLON) { ret null; }
                }

                ret new ExpressionStmtNode(left, token.row, token.column, this.file) as *const ASTNode;
            }
        }
    }

    priv ParseConstantDeclaration(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::CONST);
        if token._type == TokenType::UNKNOWN { ret null; }
        let identifier: Token = this.Expect(TokenType::IDENTIFIER);
        if identifier._type == TokenType::UNKNOWN { ret null; }
        let mut sizes: Vector<*const ASTNode>;

        while this.Match(TokenType::LBRACKET) {
            if this.Match(TokenType::RBRACKET) {
                sizes.PushBack(null);
            } else {
                let expression: *const ASTNode = this.ParseExpression();
                if expression == null || !this.Expect2(TokenType::RBRACKET) { ret null; }
                sizes.PushBack(expression);
            }
        }

        if !this.Expect2(TokenType::COLON) { ret null; }
        let mut _type: *const ASTNode = this.ParseType();
        if _type == null { ret null; }
        let mut i: u64 = 0u64;

        while i < sizes.Size() {
            _type = new ArrayTypeNode(_type, sizes[i], token.row, token.column, this.file) as *const ASTNode;
            i += 1u64;
        }

        if !this.Expect2(TokenType::ASSIGN) { ret null; }
        let initializer: *const ASTNode = this.ParseExpression();
        if initializer == null || !this.Expect2(TokenType::SEMICOLON) { ret null; }
        ret new ConstantDeclNode(identifier.value, _type, initializer, token.row, token.column, this.file) as *const ASTNode;
    }

    priv ParseStaticDeclaration(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::STATIC);
        if token._type == TokenType::UNKNOWN { ret null; }
        let mutable: bool = this.Match(TokenType::MUT);
        let identifier: Token = this.Expect(TokenType::IDENTIFIER);
        if identifier._type == TokenType::UNKNOWN { ret null; }
        let mut sizes: Vector<*const ASTNode>;

        while this.Match(TokenType::LBRACKET) {
            if this.Match(TokenType::RBRACKET) {
                sizes.PushBack(null);
            } else {
                let expression: *const ASTNode = this.ParseExpression();
                if expression == null || !this.Expect2(TokenType::RBRACKET) { ret null; }
                sizes.PushBack(expression);
            }
        }

        if !this.Expect2(TokenType::COLON) { ret null; }
        let mut _type: *const ASTNode = this.ParseType();
        if _type == null { ret null; }
        let mut i: u64 = 0u64;

        while i < sizes.Size() {
            _type = new ArrayTypeNode(_type, sizes[i], token.row, token.column, this.file) as *const ASTNode;
            i += 1u64;
        }

        let mut initializer: *const ASTNode = null;

        if this.Match(TokenType::ASSIGN) {
            initializer = this.ParseExpression();
            if initializer == null { ret null; }
        }

        if !this.Expect2(TokenType::SEMICOLON) { ret null; }
        ret new StaticDeclNode(identifier.value, _type, initializer, mutable, token.row, token.column, this.file) as *const ASTNode;
    }

    priv ParseVariableDeclaration(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::LET);
        if token._type == TokenType::UNKNOWN { ret null; }
        let multiple: bool = this.Match(TokenType::LPAREN);
        let mut current: *mut VariableDeclNode = null;
        let mut root: *const VariableDeclNode = null;

        while root == null || (multiple && root != null && this.Match(TokenType::COMMA)) {
            let mutable: bool = this.Match(TokenType::MUT);
            let identifier: Token = this.Expect(TokenType::IDENTIFIER);
            if identifier._type == TokenType::UNKNOWN { ret null; }
            let mut sizes: Vector<*const ASTNode>;

            while this.Match(TokenType::LBRACKET) {
                if this.Match(TokenType::RBRACKET) {
                    sizes.PushBack(null);
                } else {
                    let expression: *const ASTNode = this.ParseExpression();
                    if expression == null || !this.Expect2(TokenType::RBRACKET) { ret null; }
                    sizes.PushBack(expression);
                }
            }

            if !this.Expect2(TokenType::COLON) { ret null; }
            let mut _type: *const ASTNode = this.ParseType();
            if _type == null { ret null; }
            let mut i: u64 = 0u64;

            while i < sizes.Size() {
                _type = new ArrayTypeNode(_type, sizes[i], token.row, token.column, this.file) as *const ASTNode;
                i += 1u64;
            }

            let declaration: *const VariableDeclNode = new VariableDeclNode(identifier.value, _type, null, mutable, token.row, token.column, this.file);

            if root != null {
                current->next = declaration;
            } else {
                root = declaration;
            } current = declaration;
        }

        if multiple {
            if !this.Expect2(TokenType::RPAREN) { ret null; }
        }

        if this.Match(TokenType::ASSIGN) {
            if multiple {
                if !this.Expect2(TokenType::LPAREN) { ret null; }
            } current = root;

            while current != null {
                current->initializer = this.ParseExpression();
                if current->initializer == null { ret null; }

                if current->initializer->node_type == ASTNodeType::INITIALIZER_LIST {
                    let list: *const InitializerListNode = current->initializer as *const InitializerListNode;

                    if current->_type->node_type == ASTNodeType::ARRAY_TYPE {
                        let array_type: *mut ArrayTypeNode = current->_type as *const ArrayTypeNode;

                        if array_type->size == null {
                            array_type->size = new LiteralNode(String(list->expressions.Size() as i64) + "u64", TokenType::INTEGER, token.row, token.column, this.file) as *const ASTNode;
                        }
                    }
                }

                if current->next != null {
                    if !this.Expect2(TokenType::COMMA) { ret null; }
                } current = current->next;
            }

            if multiple {
                if !this.Expect2(TokenType::RPAREN) { ret null; }
            }
        }

        if !this.Expect2(TokenType::SEMICOLON) { ret null; }
        ret root as *const ASTNode;
    }

    priv ParseIfStatement(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::IF);
        if token._type == TokenType::UNKNOWN { ret null; }

        if this.Current()._type == TokenType::LET {
            this.Advance();
            let pattern: *const ASTNode = this.ParsePattern();
            if pattern == null || !this.Expect2(TokenType::ASSIGN) { ret null; }
            let expression: *const ASTNode = this.ParseExpression();
            if expression == null { ret null; }
            let then_stmt: *const ASTNode = this.ParseBlockStatement();
            if then_stmt == null { ret null; }
            let if_let: *mut IfLetStmtNode = new IfLetStmtNode(pattern, expression, then_stmt, token.row, token.column, this.file);

            if this.Match(TokenType::ELSE) {
                if this.Current()._type == TokenType::IF {
                    if_let->else_stmt = this.ParseIfStatement();
                } else {
                    if_let->else_stmt = this.ParseBlockStatement();
                }
            } ret if_let as *const ASTNode;
        }

        let condition: *const ASTNode = this.ParseExpression();
        if condition == null { ret null; }
        let then_stmt: *const ASTNode = this.ParseBlockStatement();
        if then_stmt == null { ret null; }
        let mut else_stmt: *const ASTNode = null;

        if this.Match(TokenType::ELSE) {
            if this.Current()._type == TokenType::IF {
                else_stmt = this.ParseIfStatement();
            } else {
                else_stmt = this.ParseBlockStatement();
            }
        }

        ret new IfStmtNode(condition, then_stmt, else_stmt, token.row, token.column, this.file) as *const ASTNode;
    }

    priv ParseWhileStatement(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::WHILE);
        if token._type == TokenType::UNKNOWN { ret null; }

        if this.Current()._type == TokenType::LET {
            this.Advance();
            let pattern: *const ASTNode = this.ParsePattern();
            if pattern == null || !this.Expect2(TokenType::ASSIGN) { ret null; }
            let expression: *const ASTNode = this.ParseExpression();
            if expression == null { ret null; }
            let loop_stmt: *const ASTNode = this.ParseBlockStatement();
            if loop_stmt == null { ret null; }
            ret new WhileLetStmtNode(pattern, expression, loop_stmt, token.row, token.column, this.file) as *const ASTNode;
        }

        let expression: *const ASTNode = this.ParseExpression();
        if expression == null { ret null; }
        let loop_stmt: *const ASTNode = this.ParseBlockStatement();
        if loop_stmt == null { ret null; }
        let mut else_stmt: *const ASTNode = null;

        if this.Match(TokenType::ELSE) {
            else_stmt = this.ParseBlockStatement();
        }

        ret new WhileStmtNode(expression, loop_stmt, else_stmt, token.row, token.column, this.file) as *const ASTNode;
    }

    priv ParseForStatement(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::FOR);
        if token._type == TokenType::UNKNOWN { ret null; }
        let name: Token = this.Expect(TokenType::IDENTIFIER);
        if name._type == TokenType::UNKNOWN { ret null; }
        if !this.Expect2(TokenType::IN) { ret null; }
        let iterable: *const ASTNode = this.ParseForIterable();
        if iterable == null { ret null; }
        let loop_stmt: *const ASTNode = this.ParseBlockStatement();
        if loop_stmt == null { ret null; }
        ret new ForStmtNode(name.value, iterable, loop_stmt, token.row, token.column, this.file) as *const ASTNode;
    }

    priv ParseForIterable(this: &mut Parser) -> *const ASTNode {
        let left: *const ASTNode = this.ParseBinaryExpression(0i32);
        if left == null { ret null; }

        if this.Current()._type == TokenType::TWO_DOT {
            let token: Token = this.Advance();
            let inclusive: bool = this.Match(TokenType::ASSIGN);
            let right: *const ASTNode = this.ParseBinaryExpression(0i32);
            if right == null { ret null; }
            let range: *mut RangeExprNode = new RangeExprNode(left, right, token.row, token.column, this.file);
            range->inclusive = inclusive;
            ret range as *const ASTNode;
        } ret left;
    }

    priv ParseLoopStatement(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::LOOP);
        if token._type == TokenType::UNKNOWN { ret null; }
        let loop_stmt: *const ASTNode = this.ParseBlockStatement();
        if loop_stmt == null { ret null; }
        ret new LoopStmtNode(loop_stmt, token.row, token.column, this.file) as *const ASTNode;
    }

    priv ConvertBitwiseToPattern(this: &mut Parser, node: *const ASTNode) -> *const ASTNode {
        if node->node_type != ASTNodeType::BINARY_OP { ret node; }
        let binary_operation: *const BinaryOpNode = node as *const BinaryOpNode;
        if binary_operation->operator != TokenType::BITWISE_OR { ret node; }
        let left: *const ASTNode = this.ConvertBitwiseToPattern(binary_operation->left);
        let right: *const ASTNode = this.ConvertBitwiseToPattern(binary_operation->right);
        ret new OrPatternNode(left, right, node->row, node->column, node->file) as *const ASTNode;
    }

    priv ParsePattern(this: &mut Parser) -> *const ASTNode {
        ret this.ParseSinglePattern();
    }

    priv ParseSinglePattern(this: &mut Parser) -> *const ASTNode {
        if this.Current()._type == TokenType::IDENTIFIER && this.Current().value == "_" {
            let token: Token = this.Current();
            this.Advance();
            ret new IdentifierNode({ "_" } as String, token.row, token.column, this.file) as *const ASTNode;
        }

        let expression: *const ASTNode = this.ParseExpression();
        if expression == null { ret null; }
        let converted: *const ASTNode = this.ConvertBitwiseToPattern(expression);
        if converted != expression { ret converted; }

        if this.Current()._type == TokenType::LBRACE && (expression->node_type == ASTNodeType::IDENTIFIER || expression->node_type == ASTNodeType::SCOPE_RESOLUTION) {
            let brace_token: Token = this.Current();
            this.Advance();
            let struct_pattern: *mut StructInitNode = new StructInitNode(expression, brace_token.row, brace_token.column, this.file);

            while this.Current()._type != TokenType::RBRACE && this.Current()._type != TokenType::EOF {
                if this.Current()._type == TokenType::TWO_DOT {
                    this.Advance();
                    break;
                }

                let field_name: Token = this.Expect(TokenType::IDENTIFIER);
                if field_name._type == TokenType::UNKNOWN { ret null; }

                if this.Match(TokenType::COLON) {
                    let pattern: *const ASTNode = this.ParsePattern();
                    if pattern == null { ret null; }
                    struct_pattern->field_values.PushBack(pattern);
                } else {
                    struct_pattern->field_values.PushBack(new IdentifierNode(field_name.value, field_name.row, field_name.column, this.file) as *const ASTNode);
                }

                struct_pattern->field_names.PushBack(field_name.value);
                if !this.Match(TokenType::COMMA) { break; }
            }

            if !this.Expect2(TokenType::RBRACE) { ret null; }
            ret struct_pattern as *const ASTNode;
        } ret expression;
    }

    priv ParseMatchStatement(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::MATCH);
        if token._type == TokenType::UNKNOWN { ret null; }
        let expression: *const ASTNode = this.ParseExpression();
        if expression == null { ret null; }
        let match_node: *mut MatchStmtNode = new MatchStmtNode(expression, token.row, token.column, this.file);
        if !this.Expect2(TokenType::LBRACE) { ret null; }

        while this.Current()._type != TokenType::RBRACE && this.Current()._type != TokenType::EOF {
            let mut pattern: *const ASTNode = null;

            if this.Current()._type == TokenType::IDENTIFIER && this.Current().value == "_" && this.Peek(1u64)._type == TokenType::FAT_ARROW {
                this.Advance();
            } else {
                pattern = this.ParsePattern();
                if pattern == null { ret null; }
            }

            let mut guard: *const ASTNode = null;

            if pattern != null && this.Current()._type == TokenType::IF {
                this.Advance();
                guard = this.ParseExpression();
                if guard == null { ret null; }
            }

            if !this.Expect2(TokenType::FAT_ARROW) { break; }
            let mut body: *const ASTNode = null;

            if this.Current()._type == TokenType::LBRACE {
                body = this.ParseBlockStatement();
                if body == null { ret null; }
            } else {
                body = this.ParseStatement(true);
                if body == null { ret null; }
            }

            if pattern == null {
                match_node->default_case = new DefaultStmtNode(body, token.row, token.column, this.file);
            } else {
                match_node->cases.PushBack(new CaseStmtNode(pattern, body, guard, token.row, token.column, this.file));
            }

            if !this.Match(TokenType::COMMA) {
                break;
            }
        }

        if !this.Expect2(TokenType::RBRACE) { ret null; }
        ret match_node as *const ASTNode;
    }

    priv ParseReturnStatement(this: &mut Parser, expression: bool) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::RETURN);
        if token._type == TokenType::UNKNOWN { ret null; }
        let mut value: *const ASTNode = null;

        if this.Current()._type != TokenType::SEMICOLON {
            value = this.ParseExpression();
            if value == null { ret null; }
        }

        if !expression {
            if !this.Expect2(TokenType::SEMICOLON) { ret null; }
        }

        ret new ReturnStmtNode(value, token.row, token.column, this.file) as *const ASTNode;
    }

    priv ParseBreakStatement(this: &mut Parser, expression: bool) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::BREAK);
        if token._type == TokenType::UNKNOWN { ret null; }

        if !expression {
            if !this.Expect2(TokenType::SEMICOLON) { ret null; }
        }

        ret new BreakStmtNode(token.row, token.column, this.file) as *const ASTNode;
    }

    priv ParseContinueStatement(this: &mut Parser, expression: bool) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::CONTINUE);
        if token._type == TokenType::UNKNOWN { ret null; }

        if !expression {
            if !this.Expect2(TokenType::SEMICOLON) { ret null; }
        }

        ret new ContinueStmtNode(token.row, token.column, this.file) as *const ASTNode;
    }

    priv ParseBlockStatement(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::LBRACE);
        if token._type == TokenType::UNKNOWN { ret null; }
        let block: *mut BlockStmtNode = new BlockStmtNode(token.row, token.column, this.file);

        while this.Current()._type != TokenType::RBRACE && this.Current()._type != TokenType::EOF {
            let statement: *const ASTNode = this.ParseStatement(false);

            if statement != null {
                block->statements.PushBack(statement);
            } else {
                while this.Current()._type != TokenType::EOF && this.Current()._type != TokenType::RBRACE {
                    let _type: TokenType = this.Current()._type;

                    if _type == TokenType::SEMICOLON {
                        this.Advance();
                        break;
                    }

                    if _type == TokenType::LET || _type == TokenType::IF || _type == TokenType::WHILE || _type == TokenType::FOR || _type == TokenType::LOOP || _type == TokenType::MATCH || _type == TokenType::RETURN || _type == TokenType::BREAK || _type == TokenType::CONTINUE || _type == TokenType::ASSEMBLY || _type == TokenType::VOLATILE {
                        break;
                    }

                    this.Advance();
                }
            }
        }

        if !this.Expect2(TokenType::RBRACE) { ret null; }
        ret block as *const ASTNode;
    }

    priv ParseInlineAsm(this: &mut Parser) -> *const ASTNode {
        let _volatile: bool = this.Match(TokenType::VOLATILE);
        let token: Token = this.Expect(TokenType::ASSEMBLY);
        if token._type == TokenType::UNKNOWN { ret null; }
        let node: *mut InlineAsmNode = new InlineAsmNode(_volatile, token.row, token.column, this.file);

        if this.Match(TokenType::COLON) {
            while this.Current()._type == TokenType::IDENTIFIER {
                let register: String = this.Advance().value;
                if !this.Expect2(TokenType::LPAREN) { ret null; }
                let expression: *const ASTNode = this.ParseExpression();
                if expression == null || !this.Expect2(TokenType::RPAREN) { ret null; }
                node->inputs.PushBack(Pair<String, *const ASTNode>(register, expression));
                if !this.Match(TokenType::COMMA) { break; }
            }

            if !this.Expect2(TokenType::ARROW) { ret null; }
        }

        let code: Token = this.Expect(TokenType::ASSEMBLY_CODE);
        if code._type == TokenType::UNKNOWN { ret null; }
        node->code = code.value;

        if this.Match(TokenType::ARROW) {
            while this.Current()._type == TokenType::IDENTIFIER {
                let register: String = this.Advance().value;
                if !this.Expect2(TokenType::LPAREN) { ret null; }
                let expression: *const ASTNode = this.ParseExpression();
                if expression == null || !this.Expect2(TokenType::RPAREN) { ret null; }
                node->outputs.PushBack(Pair<String, *const ASTNode>(register, expression));
                if !this.Match(TokenType::COMMA) { break; }
            }
        }

        if this.Match(TokenType::COLON) {
            while this.Current()._type == TokenType::IDENTIFIER {
                node->clobbers.PushBack(this.Advance().value);
                if !this.Match(TokenType::COMMA) { break; }
            }
        }

        if !this.Expect2(TokenType::SEMICOLON) { ret null; }
        ret node as *const ASTNode;
    }

    priv SynchronizeDeclaration(this: &mut Parser) {
        while this.Current()._type != TokenType::EOF {
            let _type: TokenType = this.Current()._type;

            if _type == TokenType::FUNC || _type == TokenType::CLASS || _type == TokenType::ENUM || _type == TokenType::EXTERN || _type == TokenType::INCLUDE || _type == TokenType::CONST || _type == TokenType::STATIC || _type == TokenType::TYPE || _type == TokenType::ASSEMBLY || _type == TokenType::VOLATILE {
                break;
            }

            this.Advance();
        }
    }

    priv ParseDeclaration(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Current();

        if token._type == TokenType::FUNC {
            ret this.ParseFunctionDeclaration();
        } else if token._type == TokenType::CLASS {
            ret this.ParseClassDeclaration();
        } else if token._type == TokenType::ENUM {
            ret this.ParseEnumDeclaration();
        } else if token._type == TokenType::EXTERN {
            ret this.ParseExternBlock();
        } else if token._type == TokenType::INCLUDE {
            ret this.ParseIncludeStatement();
        } else if token._type == TokenType::CONST {
            ret this.ParseConstantDeclaration();
        } else if token._type == TokenType::STATIC {
            ret this.ParseStaticDeclaration();
        } else if token._type == TokenType::TYPE {
            ret this.ParseTypeDeclaration();
        } else if token._type == TokenType::ASSEMBLY || token._type == TokenType::VOLATILE {
            ret this.ParseInlineAsm();
        } else {
            this.Advance();
            Logger::Log(this.file, "Expected declaration.", token, LogSeverity::Error);
            ret null;
        }
    }

    priv ParseTypeDeclaration(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::TYPE);
        if token._type == TokenType::UNKNOWN { ret null; }
        let identifier: Token = this.Expect(TokenType::IDENTIFIER);
        if identifier._type == TokenType::UNKNOWN { ret null; }

        if this.types.Index(identifier.value) != -1i64 {
            Logger::Log(this.file, String("Type '") + identifier.value + "' is overloaded.", token, LogSeverity::Error);
            ret null;
        }

        this.types.PushBack(identifier.value);
        if !this.Expect2(TokenType::ASSIGN) { ret null; }
        let _type: *const ASTNode = this.ParseType();
        if _type == null { ret null; }
        let type_decl: *const TypeDeclNode = new TypeDeclNode(identifier.value, _type, token.row, token.column, this.file);
        if !this.Expect2(TokenType::SEMICOLON) { ret null; }
        ret type_decl as *const ASTNode;
    }

    priv ParseFunctionDeclaration(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Current();
        if token._type == TokenType::UNKNOWN { ret null; }
        let mut name: String;

        if token._type == TokenType::TILDE || token._type == TokenType::FUNC || token._type == TokenType::PUBLIC || token._type == TokenType::PRIVATE {
            this.Advance();

            if token._type == TokenType::TILDE {
                name += token.value;
            }
        }

        if this.Match(TokenType::OPERATOR) {
            name += "op";

            while this.Current()._type != TokenType::LPAREN {
                name += this.Current().value;
                this.Advance();
            }
        } else {
            let identifier: Token = this.Expect(TokenType::IDENTIFIER);
            if identifier._type == TokenType::UNKNOWN { ret null; }
            name += identifier.value;
        }

        let func_type: *mut FunctionTypeNode = new FunctionTypeNode(token.row, token.column, this.file);
        let func_decl: *mut FunctionDeclNode = new FunctionDeclNode(name, func_type, token.row, token.column, this.file);

        if this.Match(TokenType::LESS) {
            let type_name: Token = this.Expect(TokenType::IDENTIFIER);
            if type_name._type == TokenType::UNKNOWN { ret null; }
            func_decl->types.PushBack(type_name.value);

            while this.Match(TokenType::COMMA) {
                let type_name: Token = this.Expect(TokenType::IDENTIFIER);
                if type_name._type == TokenType::UNKNOWN { ret null; }
                func_decl->types.PushBack(type_name.value);
            }

            if !this.Expect2(TokenType::GREATER) { ret null; }
            func_decl->generic = true;
        }

        if !this.Expect2(TokenType::LPAREN) { ret null; }

        if this.Current()._type != TokenType::RPAREN {
            func_type->var_arg = this.Match(TokenType::THREE_DOT);

            if !func_type->var_arg {
                let param: *const ParameterNode = this.ParseParameter();
                if param == null { ret null; }
                func_type->parameters.PushBack(param);

                while this.Match(TokenType::COMMA) {
                    func_type->var_arg = this.Match(TokenType::THREE_DOT);
                    if func_type->var_arg { break; }

                    let param: *const ParameterNode = this.ParseParameter();
                    if param == null { ret null; }
                    func_type->parameters.PushBack(param);
                }
            }
        }

        if !this.Expect2(TokenType::RPAREN) { ret null; }

        if this.Match(TokenType::ASYNC) {
            func_decl->is_async = true;
        }

        if this.Match(TokenType::ARROW) {
            func_type->return_type = this.ParseType();
            if func_type->return_type == null { ret null; }
        } else {
            func_type->return_type = new PrimitiveTypeNode({ "void" } as String, token.row, token.column, this.file) as *const ASTNode;

            if token._type != TokenType::FUNC && token._type != TokenType::PUBLIC && token._type != TokenType::PRIVATE {
                while (this.Match(TokenType::COLON) && func_decl->constructors.Empty()) || (this.Match(TokenType::COMMA) && !func_decl->constructors.Empty()) {
                    let expression: *const ASTNode = this.ParseExpression();
                    if expression == null { ret null; }

                    if expression->node_type == ASTNodeType::CALL {
                        func_decl->constructors.PushBack(expression as *const CallNode);
                    } else {
                        Logger::Log(this.file, "Expected a function call.", token, LogSeverity::Error);
                        break;
                    }
                }
            }
        }

        if this.Current()._type == TokenType::LBRACE {
            let body: *const ASTNode = this.ParseBlockStatement();
            if body == null { ret null; }
            func_decl->body = body as *const BlockStmtNode;
        } else {
            if !this.Expect2(TokenType::SEMICOLON) { ret null; }
        } ret func_decl as *const ASTNode;
    }

    priv ParseParameter(this: &mut Parser) -> *const ParameterNode {
        let mutable: bool = this.Match(TokenType::MUT);

        if this.Peek(1u64)._type == TokenType::COLON || this.Peek(1u64)._type == TokenType::LBRACKET {
            let token: Token = this.Expect(TokenType::IDENTIFIER);
            if token._type == TokenType::UNKNOWN { ret null; }
            let mut sizes: Vector<*const ASTNode>;

            while this.Match(TokenType::LBRACKET) {
                if this.Match(TokenType::RBRACKET) {
                    sizes.PushBack(null);
                } else {
                    let expression: *const ASTNode = this.ParseExpression();
                    if expression == null || !this.Expect2(TokenType::RBRACKET) { ret null; }
                    sizes.PushBack(expression);
                }
            }

            if !this.Expect2(TokenType::COLON) { ret null; }
            let mut _type: *const ASTNode = this.ParseType();
            if _type == null { ret null; }
            let mut i: u64 = 0u64;

            while i < sizes.Size() {
                _type = new ArrayTypeNode(_type, sizes[i], token.row, token.column, this.file) as *const ASTNode;
                i += 1u64;
            }

            ret new ParameterNode(token.value, _type, mutable, token.row, token.column, this.file);
        } else {
            let token: Token = this.Current();
            let _type: *const ASTNode = this.ParseType();
            if _type == null { ret null; }
            ret new ParameterNode(String(""), _type, mutable, token.row, token.column, this.file);
        }
    }

    priv ParseClassDeclaration(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::CLASS);
        if token._type == TokenType::UNKNOWN { ret null; }
        let identifier: Token = this.Expect(TokenType::IDENTIFIER);
        if identifier._type == TokenType::UNKNOWN { ret null; }

        if this.types.Index(identifier.value) != -1i64 {
            Logger::Log(this.file, String("Type '") + identifier.value + "' is overloaded.", token, LogSeverity::Error);
            ret null;
        }

        this.types.PushBack(identifier.value);
        let class_decl: *mut ClassDeclNode = new ClassDeclNode(identifier.value, token.row, token.column, this.file);

        if this.Match(TokenType::LESS) {
            let type_name: Token = this.Expect(TokenType::IDENTIFIER);
            if type_name._type == TokenType::UNKNOWN { ret null; }
            class_decl->types.PushBack(type_name.value);

            while this.Match(TokenType::COMMA) {
                let type_name: Token = this.Expect(TokenType::IDENTIFIER);
                if type_name._type == TokenType::UNKNOWN { ret null; }
                class_decl->types.PushBack(type_name.value);
            }

            if !this.Expect2(TokenType::GREATER) { ret null; }
            class_decl->generic = true;
        }

        if this.Match(TokenType::COLON) {
            let _type: *const ASTNode = this.ParseType();
            if _type == null { ret null; }
            class_decl->parents.PushBack(_type);

            while this.Match(TokenType::COMMA) {
                let _type: *const ASTNode = this.ParseType();
                if _type == null { ret null; }
                class_decl->parents.PushBack(_type);
            }
        }

        if !this.Expect2(TokenType::LBRACE) { ret null; }

        while this.Current()._type != TokenType::RBRACE && this.Current()._type != TokenType::EOF {
            let visibility: Token = this.Current();

            if visibility._type == TokenType::PUBLIC || visibility._type == TokenType::PRIVATE {
                this.Advance();
            } else {
                Logger::Log(this.file, "Expected visibility modifier.", visibility, LogSeverity::Error);
                break;
            }

            if this.Current()._type == TokenType::IDENTIFIER {
                let field: *const FieldNode = this.ParseField();
                if field == null { ret null; }
                class_decl->fields.PushBack(Pair<TokenType, *const FieldNode>(visibility._type, field));
            } else {
                Logger::Log(this.file, "Expected field declaration.", this.Current(), LogSeverity::Error);
                break;
            }

            if !this.Match(TokenType::COMMA) {
                break;
            }
        }

        if !this.Expect2(TokenType::RBRACE) { ret null; }

        if this.Match(TokenType::IMPL) {
            if !this.Expect2(TokenType::LBRACE) { ret null; }

            while this.Current()._type != TokenType::RBRACE && this.Current()._type != TokenType::EOF {
                let visibility: Token = this.Current();

                if visibility._type == TokenType::PUBLIC || visibility._type == TokenType::PRIVATE {
                    let function: *const ASTNode = this.ParseFunctionDeclaration();
                    if function == null { ret null; }
                    class_decl->methods.PushBack(Pair<TokenType, *const FunctionDeclNode>(visibility._type, function as *const FunctionDeclNode));
                } else {
                    if this.Current()._type == TokenType::TILDE {
                        if class_decl->destructor != null {
                            Logger::Log(this.file, "Multiple destructor declarations are not allowed.", visibility, LogSeverity::Error);
                            break;
                        }

                        let function: *const ASTNode = this.ParseFunctionDeclaration();
                        if function == null { ret null; }
                        class_decl->destructor = function as *const FunctionDeclNode;
                    } else {
                        let function: *const ASTNode = this.ParseFunctionDeclaration();
                        if function == null { ret null; }
                        class_decl->constructors.PushBack(function as *const FunctionDeclNode);
                    }
                }
            }

            if !this.Expect2(TokenType::RBRACE) { ret null; }
        }

        if !this.Expect2(TokenType::SEMICOLON) { ret null; }
        ret class_decl as *const ASTNode;
    }

    priv ParseField(this: &mut Parser) -> *const FieldNode {
        let token: Token = this.Expect(TokenType::IDENTIFIER);
        if token._type == TokenType::UNKNOWN { ret null; }
        let mut sizes: Vector<*const ASTNode>;

        while this.Match(TokenType::LBRACKET) {
            if this.Match(TokenType::RBRACKET) {
                sizes.PushBack(null);
            } else {
                let expression: *const ASTNode = this.ParseExpression();
                if expression == null || !this.Expect2(TokenType::RBRACKET) { ret null; }
                sizes.PushBack(expression);
            }
        }

        if !this.Expect2(TokenType::COLON) { ret null; }
        let mut field_type: *const ASTNode = this.ParseType();
        if field_type == null { ret null; }
        let mut initializer: *const ASTNode = null;
        let mut i: u64 = 0u64;

        while i < sizes.Size() {
            field_type = new ArrayTypeNode(field_type, sizes[i], token.row, token.column, this.file) as *const ASTNode;
            i += 1u64;
        }

        if this.Match(TokenType::ASSIGN) {
            initializer = this.ParseExpression();
            if initializer == null { ret null; }
        }

        ret new FieldNode(token.value, field_type, initializer, token.row, token.column, this.file);
    }

    priv ParseEnumDeclaration(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::ENUM);
        if token._type == TokenType::UNKNOWN { ret null; }
        let identifier: Token = this.Expect(TokenType::IDENTIFIER);
        if identifier._type == TokenType::UNKNOWN { ret null; }

        if this.types.Index(identifier.value) != -1i64 {
            Logger::Log(this.file, String("Type '") + identifier.value + "' is overloaded.", token, LogSeverity::Error);
            ret null;
        }

        this.types.PushBack(identifier.value);
        let enum_decl: *mut EnumDeclNode = new EnumDeclNode(identifier.value, token.row, token.column, this.file);

        if this.Match(TokenType::LESS) {
            let type_name: Token = this.Expect(TokenType::IDENTIFIER);
            if type_name._type == TokenType::UNKNOWN { ret null; }
            enum_decl->types.PushBack(type_name.value);

            while this.Match(TokenType::COMMA) {
                let type_name: Token = this.Expect(TokenType::IDENTIFIER);
                if type_name._type == TokenType::UNKNOWN { ret null; }
                enum_decl->types.PushBack(type_name.value);
            }

            if !this.Expect2(TokenType::GREATER) { ret null; }
            enum_decl->generic = true;
        }

        if this.Match(TokenType::COLON) {
            enum_decl->underlying_type = this.ParseType();
            if enum_decl->underlying_type == null { ret null; }
        } else {
            enum_decl->underlying_type = new PrimitiveTypeNode({ "i32" } as String, token.row, token.column, this.file) as *const ASTNode;
        }

        if !this.Expect2(TokenType::LBRACE) { ret null; }

        while this.Current()._type != TokenType::RBRACE && this.Current()._type != TokenType::EOF {
            let variant_name: Token = this.Expect(TokenType::IDENTIFIER);
            if variant_name._type == TokenType::UNKNOWN { break; }
            let variant: *mut VariantNode = new VariantNode(variant_name.value, variant_name.row, variant_name.column, this.file);

            if this.Match(TokenType::LBRACE) {
                while this.Current()._type != TokenType::RBRACE && this.Current()._type != TokenType::EOF {
                    let field_name: Token = this.Expect(TokenType::IDENTIFIER);
                    if field_name._type == TokenType::UNKNOWN { ret null; }
                    if !this.Expect2(TokenType::COLON) { ret null; }
                    variant->field_names.PushBack(field_name.value);
                    let field_type: *const ASTNode = this.ParseType();
                    if field_type == null { ret null; }
                    variant->types.PushBack(field_type);
                    if !this.Match(TokenType::COMMA) { break; }
                }

                if !this.Expect2(TokenType::RBRACE) { ret null; }
            } else if this.Match(TokenType::LPAREN) {
                let variant_type: *const ASTNode = this.ParseType();
                if variant_type == null { ret null; }
                variant->types.PushBack(variant_type);

                while this.Match(TokenType::COMMA) {
                    let variant_type: *const ASTNode = this.ParseType();
                    if variant_type == null { ret null; }
                    variant->types.PushBack(variant_type);
                }

                if !this.Expect2(TokenType::RPAREN) { ret null; }
            } else if this.Match(TokenType::ASSIGN) {
                variant->value = this.ParseExpression();
                if variant->value == null { ret null; }
            }

            enum_decl->variants.PushBack(variant);

            if !this.Match(TokenType::COMMA) {
                break;
            }
        }

        if !this.Expect2(TokenType::RBRACE) { ret null; }

        if this.Match(TokenType::IMPL) {
            if !this.Expect2(TokenType::LBRACE) { ret null; }

            while this.Current()._type != TokenType::RBRACE && this.Current()._type != TokenType::EOF {
                let visibility: Token = this.Current();

                if visibility._type == TokenType::PUBLIC || visibility._type == TokenType::PRIVATE {
                    let function: *const ASTNode = this.ParseFunctionDeclaration();
                    if function == null { ret null; }
                    enum_decl->methods.PushBack(Pair<TokenType, *const FunctionDeclNode>(visibility._type, function as *const FunctionDeclNode));
                } else {
                    Logger::Log(this.file, "Expected visibility modifier.", visibility, LogSeverity::Error);
                    break;
                }
            }

            if !this.Expect2(TokenType::RBRACE) { ret null; }
        }

        if !this.Expect2(TokenType::SEMICOLON) { ret null; }
        ret enum_decl as *const ASTNode;
    }

    priv ParseExternBlock(this: &mut Parser) -> *const ASTNode {
        let extern_token: Token = this.Expect(TokenType::EXTERN);
        if extern_token._type == TokenType::UNKNOWN { ret null; }
        let linkage_token: Token = this.Expect(TokenType::STRING);
        if linkage_token._type == TokenType::UNKNOWN { ret null; }
        let extern_block: *mut ExternBlockNode = new ExternBlockNode(linkage_token.value, extern_token.row, extern_token.column, this.file);
        if !this.Expect2(TokenType::LBRACE) { ret null; }

        while this.Current()._type != TokenType::RBRACE && this.Current()._type != TokenType::EOF {
            if this.Current()._type == TokenType::FUNC {
                let function: *const ASTNode = this.ParseFunctionDeclaration();

                if function == null {
                    this.SynchronizeDeclaration();
                    continue;
                }

                extern_block->declarations.PushBack(function);
            } else if this.Current()._type == TokenType::STATIC {
                let _static: *const ASTNode = this.ParseStaticDeclaration();

                if _static == null {
                    this.SynchronizeDeclaration();
                    continue;
                }

                extern_block->declarations.PushBack(_static);
            } else {
                Logger::Log(this.file, "Only function and static declarations allowed in extern block.", this.Current(), LogSeverity::Error);
                this.Advance();
                this.SynchronizeDeclaration();
            }
        }

        if !this.Expect2(TokenType::RBRACE) { ret null; }
        ret extern_block as *const ASTNode;
    }

    priv ParseIncludeStatement(this: &mut Parser) -> *const ASTNode {
        let token: Token = this.Expect(TokenType::INCLUDE);
        let mut modules: Vector<String>;

        while this.Match(TokenType::COMMA) || modules.Empty() {
            let module: Token = this.Expect(TokenType::STRING);
            if module._type == TokenType::UNKNOWN { ret null; }
            modules.PushBack(module.value);
        }

        if !this.Expect2(TokenType::COLON) { ret null; }
        if !this.Expect2(TokenType::MUL) { ret null; }
        if !this.Expect2(TokenType::SEMICOLON) { ret null; }
        let mut i: u64 = 0u64;

        while i < modules.Size() {
            let (mut found: bool, mut j: u64) = (false, 0u64);
            let module: String = modules[i];

            while j < this.include_paths.Size() {
                let mut path: String = JoinPath(this.include_paths[j], modules[i]);
                j += 1u64;

                if !PathExists(path) {
                    continue;
                }

                if FolderExists(path) {
                    path = JoinPath(path, String("Entry.div"));

                    if !PathExists(path) {
                        Logger::Log(this.file, String("Module '") + module + "' entry point not found.", token, LogSeverity::Error);
                        ret null;
                    }
                }

                path = AbsolutePath(path);

                if this.included_paths.Index(path) != -1i64 {
                    found = true;
                    break;
                }

                let mut lexer: Lexer;
                let mut preprocessor: Preprocessor;
                preprocessor.defines = this.defines;

                let (tokens: Vector<Token>, current: u64, file: String) = (this.tokens, this.index, this.file);
                (this.tokens, this.index, this.file) = (preprocessor.Process(lexer.Lex(_ReadFile(path), path), path), 0u64, path);
                this.included_paths.PushBack(path);

                while this.Current()._type != TokenType::EOF {
                    let declaration: *const ASTNode = this.ParseDeclaration();

                    if declaration != null {
                        this.root->declarations.PushBack(declaration);
                    } else {
                        this.SynchronizeDeclaration();
                    }
                }

                (this.tokens, this.index, this.file, found) = (tokens, current, file, true);
                break;
            }

            if found {
                i += 1u64;
            } else {
                Logger::Log(this.file, String("Module '") + module + "' not found.", token, LogSeverity::Error);
                ret null;
            }
        } ret null;
    }

    pub Parse(this: &mut Parser, tokens: &Vector<Token>, file: &String) -> *const RootNode {
        (this.tokens, this.index) = (tokens, 0u64);
        (this.file, this.root) = (file, new RootNode());

        this.types.Clear();
        this.types.PushBack(String("bool"));
        this.types.PushBack(String("i8"));
        this.types.PushBack(String("i16"));
        this.types.PushBack(String("i32"));
        this.types.PushBack(String("i64"));
        this.types.PushBack(String("i128"));
        this.types.PushBack(String("u8"));
        this.types.PushBack(String("u16"));
        this.types.PushBack(String("u32"));
        this.types.PushBack(String("u64"));
        this.types.PushBack(String("u128"));
        this.types.PushBack(String("f32"));
        this.types.PushBack(String("f64"));
        this.types.PushBack(String("void"));
        this.included_paths.Clear();
        this.included_paths.PushBack(AbsolutePath(file));

        while this.Current()._type != TokenType::EOF {
            let declaration: *const ASTNode = this.ParseDeclaration();

            if declaration != null {
                this.root->declarations.PushBack(declaration);
            } else {
                this.SynchronizeDeclaration();
            }
        } ret this.root;
    }
};

include "logger.div" : *;