compiler.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", "divvec", "divmap", "divpair", "divfile", "divllvm", "parser.div", "logger.div" : *;

func LLVMPositionBuilderAtStart(builder: LLVMBuilderRef, block: LLVMBasicBlockRef) {
    let first_instr: LLVMValueRef = LLVMGetFirstInstruction(block);

    if first_instr != null {
        LLVMPositionBuilderBefore(builder, first_instr);
    } else {
        LLVMPositionBuilderAtEnd(builder, block);
    }
}

func LLVMIsTypeEqual(left: LLVMTypeRef, right: LLVMTypeRef) -> bool {
    if left == right {
        ret true;
    }

    let left_kind: LLVMTypeKind = LLVMGetTypeKind(left);
    let right_kind: LLVMTypeKind = LLVMGetTypeKind(right);

    if left_kind != right_kind {
        ret false;
    } else if left_kind == LLVMTypeKind::LLVMVoidTypeKind || left_kind == LLVMTypeKind::LLVMPointerTypeKind || left_kind == LLVMTypeKind::LLVMHalfTypeKind || left_kind == LLVMTypeKind::LLVMFloatTypeKind || left_kind == LLVMTypeKind::LLVMDoubleTypeKind || left_kind == LLVMTypeKind::LLVMX86_FP80TypeKind || left_kind == LLVMTypeKind::LLVMFP128TypeKind || left_kind == LLVMTypeKind::LLVMPPC_FP128TypeKind || left_kind == LLVMTypeKind::LLVMLabelTypeKind {
        ret true;
    } else if left_kind == LLVMTypeKind::LLVMIntegerTypeKind {
        ret LLVMGetIntTypeWidth(left) == LLVMGetIntTypeWidth(right);
    } else if left_kind == LLVMTypeKind::LLVMFunctionTypeKind {
        if !LLVMIsTypeEqual(LLVMGetReturnType(left), LLVMGetReturnType(right)) {
            ret false;
        }

        let left_param_count: u32 = LLVMCountParamTypes(left);
        let right_param_count: u32 = LLVMCountParamTypes(right);

        if (left_param_count != right_param_count) {
            ret false;
        }

        let left_params: *const LLVMTypeRef = new LLVMTypeRef[left_param_count as u64];
        let right_params: *const LLVMTypeRef = new LLVMTypeRef[right_param_count as u64];

        LLVMGetParamTypes(left, left_params);
        LLVMGetParamTypes(right, right_params);
        let mut i: u32 = 0u32;

        while i < left_param_count {
            if !LLVMIsTypeEqual(left_params[i], right_params[i]) {
                del[] left_params;
                del[] right_params;
                ret false;
            } i += 1u32;
        }

        del[] left_params;
        del[] right_params;
        ret true;
    } else if left_kind == LLVMTypeKind::LLVMArrayTypeKind {
        ret LLVMGetArrayLength(left) == LLVMGetArrayLength(right) && LLVMIsTypeEqual(LLVMGetElementType(left), LLVMGetElementType(right));
    } else if left_kind == LLVMTypeKind::LLVMStructTypeKind {
        let left_name: *const i8 = LLVMGetStructName(left);
        let right_name: *const i8 = LLVMGetStructName(right);
            
        if left_name != null && right_name != null {
            ret String(left_name) == right_name;
        }

        let left_elem_count: u32 = LLVMCountStructElementTypes(left);
        let right_elem_count: u32 = LLVMCountStructElementTypes(right);
        
        if left_elem_count != right_elem_count {
            ret false;
        }

        if LLVMIsPackedStruct(left) != LLVMIsPackedStruct(right) {
            ret false;
        }

        let left_elems: *const LLVMTypeRef = new LLVMTypeRef[left_elem_count as u64];
        let right_elems: *const LLVMTypeRef = new LLVMTypeRef[right_elem_count as u64];

        LLVMGetStructElementTypes(left, left_elems);
        LLVMGetStructElementTypes(right, right_elems);
        let mut i: u32 = 0u32;

        while i < left_elem_count {
            if !LLVMIsTypeEqual(left_elems[i], right_elems[i]) {
                del[] left_elems;
                del[] right_elems;
                ret false;
            } i += 1u32;
        }
        
        del[] left_elems;
        del[] right_elems;
        ret true;
    } else if left_kind == LLVMTypeKind::LLVMVectorTypeKind {
        ret LLVMGetVectorSize(left) == LLVMGetVectorSize(right) && LLVMIsTypeEqual(LLVMGetElementType(left), LLVMGetElementType(right));
    } else {
        ret false;
    }
}

func LLVMTypeToString(_type: LLVMTypeRef) -> String {
    let mut result: String;
    let string: *const i8 = LLVMPrintTypeToString(_type);
    result += string;
    LLVMDisposeMessage(string);
    ret result;
}

func LLVMValueToString(value: LLVMValueRef) -> String {
    let mut result: String;
    let string: *const i8 = LLVMPrintValueToString(value);
    result += string;
    LLVMDisposeMessage(string);
    ret result;
}

func LLVMAddressOf(value: LLVMValueRef, builder: LLVMBuilderRef) -> LLVMValueRef {
    if LLVMGetInstructionOpcode(value) == LLVMOpcode::LLVMLoad {
        let operand: LLVMValueRef = LLVMGetOperand(value, 0u32);
        LLVMInstructionEraseFromParent(value);
        ret operand;
    } else if LLVMGetInstructionOpcode(value) == LLVMOpcode::LLVMPHI {
        let count: u32 = LLVMCountIncoming(value);
        let current: LLVMBasicBlockRef = LLVMGetInsertBlock(builder);
        LLVMPositionBuilderBefore(builder, value);
        let result: LLVMValueRef = LLVMBuildPhi(builder, LLVMPointerType(LLVMTypeOf(value), 0u32), "");
        let mut i: u32 = 0u32;

        while i < count {
            let block: LLVMBasicBlockRef = LLVMGetIncomingBlock(value, i);
            let value: LLVMValueRef = LLVMAddressOf(LLVMGetIncomingValue(value, i), builder);
            LLVMAddIncoming(result, &value, &block, 1u32);
            i += 1u32;
        }

        LLVMInstructionEraseFromParent(value);
        LLVMPositionBuilderAtEnd(builder, current);
        ret result;
    } else {
        WriteLine("\x1b[31mFailed to get address of '" + LLVMValueToString(value) + "'.\x1b[0m");
        Exit(1i32);
        ret null;
    }
}

class Field {
    pub initializer: *const ASTNode,
    pub visibility: TokenType,
    pub index: u64 = 0u64;

    Field(&mut this, initializer: *const ASTNode, visibility: TokenType, index: u64) {
        (this.initializer, this.visibility, this.index) = (initializer, visibility, index);
    }

    ~Field(&this) {}
}

class Method {
    pub name: String,
    pub value: LLVMValueRef,
    pub visibility: TokenType;

    Method(&mut this, name: String, value: LLVMValueRef, visibility: TokenType) {
        (this.name, this.value, this.visibility) = (name, value, visibility);
    }

    ~Method(&this) {}
}

class QualifiedType {
    priv value: LLVMTypeRef, priv pointee: *const QualifiedType = null,
    priv reference: bool = false, priv mutable: bool = false, priv signed: bool = false,
    priv array: bool = false, priv size: u64 = 0u64, pub _null: bool = false,

    pub constructed: Vector<*const QualifiedType>,
    pub fields: Map<String, Pair<Field, *const QualifiedType>>,
    pub methods: Vector<Pair<Method, *const QualifiedType>>,
    pub variants: Vector<Pair<String, Vector<*const QualifiedType>>>,
    pub variant_field_names: Vector<Vector<String>>,
    pub name: String, priv _class: bool = false, pub _enum: bool = false,

    pub sret: *const QualifiedType = null, pub byval: *const QualifiedType = null,
    priv params: Vector<*const QualifiedType>, priv return: *const QualifiedType = null,
    priv _function: bool = false;

    QualifiedType(&mut this, value: LLVMTypeRef, signed: bool) {
        (this.value, this.signed) = (value, signed);
    }

    QualifiedType(&mut this, value: LLVMTypeRef, params: Vector<*const QualifiedType>, return: *const QualifiedType) {
        (this.value, this.params, this.return, this._function) = (value, params, return, true);
    }

    QualifiedType(&mut this, value: LLVMTypeRef, mutable: bool, name: String, _class: bool) {
        (this.value, this.mutable, this.name, this._class, this._enum) = (value, mutable, name, _class, !_class);
    }

    QualifiedType(&mut this, value: LLVMTypeRef, mutable: bool, reference: bool, _class: bool, pointee: *const QualifiedType) {
        (this.value, this.mutable, this.reference, this._class, this.pointee) = (value, mutable, reference, _class, pointee);
    }

    QualifiedType(&mut this, value: LLVMTypeRef, mutable: bool, size: u64, _class: bool, pointee: *const QualifiedType) {
        (this.value, this.mutable, this.size, this._class, this.pointee, this.array) = (value, mutable, size, _class, pointee, true);
    }

    ~QualifiedType(&this) {}

    pub IsMutable(&this) -> bool { ret this.mutable; }
    pub IsSigned(&this) -> bool { ret this.signed; }
    pub IsPointer(&this) -> bool { ret this.pointee != null && !this.array; }
    pub IsReference(&this) -> bool { ret this.reference; }
    pub IsArray(&this) -> bool { ret this.array; }
    pub IsPrimitive(&this) -> bool { ret !this.IsPointer() && !this.IsClass(); }
    pub IsFunction(&this) -> bool { ret this._function; }
    pub IsClass(&this) -> bool { ret this._class; }
    pub IsEnum(&this) -> bool { ret this._enum; }

    pub Value(&this) -> LLVMTypeRef {
        if this.value != null {
            ret this.value;
        } else {
            Logger::Log("QualifiedType", "Null type!", LogSeverity::Error);
            ret null;
        }
    }

    pub Pointee(&this) -> &QualifiedType {
        if this.pointee != null {
            if !this.array {
                ret this.pointee;
            } else {
                Logger::Log("QualifiedType", "Not a pointer!", LogSeverity::Error);
                ret null;
            }
        } else {
            Logger::Log("QualifiedType", "Null pointee!", LogSeverity::Error);
            ret null;
        }
    }

    pub Size(&this) -> u64 {
        if this.array {
            ret this.size;
        } else {
            Logger::Log("QualifiedType", "Not an array!", LogSeverity::Error);
            ret 0u64;
        }
    }

    pub Element(&this) -> &QualifiedType {
        if this.pointee != null {
            if this.array {
                ret this.pointee;
            } else {
                Logger::Log("QualifiedType", "Not an array!", LogSeverity::Error);
                ret null;
            }
        } else {
            Logger::Log("QualifiedType", "Null pointee!", LogSeverity::Error);
            ret null;
        }
    }

    pub Parameters(&this) -> &mut Vector<*const QualifiedType> {
        if this._function {
            ret this.params;
        } else {
            Logger::Log("QualifiedType", "Not a function!", LogSeverity::Error);
            ret null;
        }
    }

    pub Return(&this) -> &QualifiedType {
        if this._function {
            ret this.return;
        } else {
            Logger::Log("QualifiedType", "Not a function!", LogSeverity::Error);
            ret null;
        }
    }

    pub Fields(&this) -> &mut Map<String, Pair<Field, *const QualifiedType>> {
        if this._class {
            ret this.fields;
        } else {
            Logger::Log("QualifiedType", "Not a class!", LogSeverity::Error);
            ret null;
        }
    }

    pub Methods(&this) -> &mut Vector<Pair<Method, *const QualifiedType>> {
        if this._class || this._enum {
            ret this.methods;
        } else {
            Logger::Log("QualifiedType", "Not a class!", LogSeverity::Error);
            ret null;
        }
    }

    pub Index(&this, name: &String) -> i64 {
        let fields: &mut Map<String, Pair<Field, *const QualifiedType>> = this.Fields();
        let mut i: u64 = 0u64;

        while i < fields.Size() {
            if fields[i].left == name {
                ret fields[i].right.left.index as i64;
            } i += 1u64;
        } ret -1i64;
    }

    pub Has(&this, name: &String, current_class: *const QualifiedType) -> bool {
        let methods: &mut Vector<Pair<Method, *const QualifiedType>> = this.Methods();
        let mut i: u64 = 0u64;

        while i < methods.Size() {
            if methods[i].left.name == name {
                if methods[i].left.visibility == TokenType::PUBLIC {
                    ret true;
                }

                if current_class != null {
                    if *current_class == this {
                        ret true;
                    }
                }
            } i += 1u64;
        } ret false;
    }

    pub Has(&this, name: &String, params: &Vector<*const QualifiedType>, current_class: *const QualifiedType) -> bool {
        let methods: &mut Vector<Pair<Method, *const QualifiedType>> = this.Methods();
        let mut i: u64 = 0u64;

        while i < methods.Size() {
            if methods[i].left.name == name {
                let mut state: bool = false;

                if current_class != null {
                    state = *current_class == this;
                }

                if methods[i].left.visibility == TokenType::PUBLIC || state {
                    let (mut _match: bool, mut j: u64) = (true, 0u64);
                    let _params: &Vector<*const QualifiedType> = methods[i].right->Pointee().Parameters();
                    let offset: u64 = _params[0u64]->sret != null ? 2u64 : 1u64;

                    if params.Size() != _params.Size() - offset {
                        i += 1u64;
                        continue;
                    }

                    while params.Size() > j {
                        let mut _type: *const QualifiedType = _params[j + offset];

                        if _type->byval != null {
                            _type = _type->byval;
                        }

                        if _type->IsReference() && *_type != *(params[j]) {
                            _type = _type->Pointee();
                        }

                        let mut _state: bool = false;

                        if params[j]->IsReference() {
                            if *_type == params[j]->Pointee() {
                                _state = true;
                            } else if _type->IsPointer() && params[j]->Pointee().IsPointer() {
                                if LLVMGetTypeKind(_type->Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(params[j]->Pointee().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                                    _state = true;
                                }
                            }
                        }

                        if _type->IsPointer() && params[j]->IsPointer() {
                            if LLVMGetTypeKind(_type->Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(params[j]->Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                                _state = true;
                            }
                        }

                        if *_type != *(params[j]) && !_state {
                            _match = false;
                            break;
                        } j += 1u64;
                    }

                    if _match {
                        ret true;
                    }
                }
            } i += 1u64;
        } ret false;
    }

    pub Get(&this, name: &String, current_class: *const QualifiedType, node: *const ASTNode) -> &mut Pair<Method, *const QualifiedType> {
        let methods: &mut Vector<Pair<Method, *const QualifiedType>> = this.Methods();
        let (mut state: u64, mut i: u64) = (0u64, 0u64);

        while i < methods.Size() {
            if methods[i].left.name == name {
                let mut _state: bool = false;

                if current_class != null {
                    _state = *current_class == this;
                }

                if methods[i].left.visibility != TokenType::PUBLIC && !_state {
                    if state < 1u64 { state = 1u64; }
                } else {
                    ret methods[i];
                }
            } i += 1u64;
        }

        if state == 0u64 {
            Logger::Log("Class '" + this.name + "' doesn't contain any member named '" + name + "'.", node, LogSeverity::Error);
            ret null;
        } else {
            Logger::Log("Function '" + name + "' is not accessible.", node, LogSeverity::Error);
            ret null;
        }
    }

    pub Get(&this, name: &String, params: &Vector<*const QualifiedType>, current_class: *const QualifiedType, node: *const ASTNode) -> &mut Pair<Method, *const QualifiedType> {
        let (mut index: u64, mut best: u64) = (0u64, 0u64);
        let methods: &mut Vector<Pair<Method, *const QualifiedType>> = this.Methods();
        let (mut state: u64, mut i: u64) = (0u64, 0u64);

        while i < methods.Size() {
            if methods[i].left.name == name {
                let mut _state: bool = false;

                if current_class != null {
                    _state = *current_class == this;
                }

                if methods[i].left.visibility != TokenType::PUBLIC && !_state {
                    if state < 1u64 { state = 1u64; }
                } else {
                    let (mut _match: bool, mut score: u64, mut j: u64) = (true, 1u64, 0u64);
                    let _params: &Vector<*const QualifiedType> = methods[i].right->Pointee().Parameters();
                    let offset: u64 = _params[0u64]->sret != null ? 2u64 : 1u64;

                    if params.Size() != _params.Size() - offset {
                        i += 1u64;
                        state = 2u64;
                        continue;
                    }

                    while params.Size() > j {
                        let mut _type: *const QualifiedType = _params[j + offset];

                        if _type->byval != null {
                            _type = _type->byval;
                        }

                        if _type->IsReference() && *_type != *(params[j]) {
                            _type = _type->Pointee();
                        }

                        let (mut _state: bool, mut state_: bool) = (false, false);

                        if params[j]->IsReference() {
                            if *_type == params[j]->Pointee() {
                                _state = true;
                            } else if _type->IsPointer() && params[j]->Pointee().IsPointer() {
                                if LLVMGetTypeKind(_type->Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || params[j]->Pointee().Pointee()._null {
                                    state_ = true;
                                }
                            }
                        }

                        if _type->IsPointer() && params[j]->IsPointer() {
                            if LLVMGetTypeKind(_type->Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || params[j]->Pointee()._null {
                                state_ = true;
                            }
                        }

                        if *_type == *(params[j]) || _state || state_ {
                            score += _state ? 3u64 : (state_ ? 1u64 : 2u64);
                        } else {
                            _match = false;
                            break;
                        } j += 1u64;
                    }

                    if !_match {
                        state = 2u64;
                    } else if score > best {
                        (index, best) = (i, score);
                    }
                }
            } i += 1u64;
        }

        if best != 0u64 {
            ret methods[index];
        } else {
            if state == 0u64 {
                Logger::Log("Class '" + this.name + "' doesn't contain any member named '" + name + "'.", node, LogSeverity::Error);
                ret null;
            } else if state == 1u64 {
                Logger::Log("Function '" + name + "' is not accessible.", node, LogSeverity::Error);
                ret null;
            } else {
                Logger::Log("Invalid arguments for: '" + name + "'.", node, LogSeverity::Error);
                ret null;
            }
        }
    }

    pub op==(&this, other: &QualifiedType) -> bool {
        if this.pointee != null && other.pointee != null {
            ret this.signed == other.signed && LLVMIsTypeEqual(this.value, other.value) && (*this.pointee) == (*other.pointee);
        } else {
            ret this.signed == other.signed && LLVMIsTypeEqual(this.value, other.value) && this.pointee == other.pointee;
        }
    }

    pub op!=(&this, other: &QualifiedType) -> bool {
        ret !(this == other);
    }
}

class TypeManager {
    priv types: Vector<*const QualifiedType>;

    TypeManager(&this) {}

    ~TypeManager(&mut this) {
        WriteLine("Disposing " + String(this.types.Size() as i64) + " types (" + String((this.types.Size() * sizeof(QualifiedType)) as f64 / 1024.0f64 / 1024.0f64) + " MB)...");
        let mut i: u64 = 0u64;

        while i < this.types.Size() {
            del this.types[i];
            i += 1u64;
        }

        this.types.Clear();
    }

    pub Primitive(&mut this, value: LLVMTypeRef, signed: bool) -> *const QualifiedType {
        let _type: *const QualifiedType = new QualifiedType(value, signed);
        this.types.PushBack(_type);
        ret _type;
    }

    pub Function(&mut this, value: LLVMTypeRef, params: Vector<*const QualifiedType>, return: *const QualifiedType) -> *const QualifiedType {
        let _type: *const QualifiedType = new QualifiedType(value, params, return);
        this.types.PushBack(_type);
        ret _type;
    }

    pub Class(&mut this, value: LLVMTypeRef, name: String) -> *const QualifiedType {
        let _type: *const QualifiedType = new QualifiedType(value, false, name, true);
        this.types.PushBack(_type);
        ret _type;
    }

    pub Enum(&mut this, value: LLVMTypeRef, name: String) -> *const QualifiedType {
        let _type: *const QualifiedType = new QualifiedType(value, false, name, false);
        this.types.PushBack(_type);
        ret _type;
    }

    pub Pointer(&mut this, pointee: *const QualifiedType, mutable: bool) -> *const QualifiedType {
        let _type: *const QualifiedType = new QualifiedType(LLVMPointerType(pointee->Value(), 0u32), mutable, false, false, pointee);
        this.types.PushBack(_type);
        ret _type;
    }

    pub NullPointer(&mut this, value: LLVMTypeRef) -> *const QualifiedType {
        let pointee: *mut QualifiedType = new QualifiedType(value, false);
        pointee->_null = true;
        this.types.PushBack(pointee);
        let _type: *const QualifiedType = new QualifiedType(LLVMPointerType(value, 0u32), false, false, false, pointee);
        this.types.PushBack(_type);
        ret _type;
    }

    pub Reference(&mut this, pointee: *const QualifiedType, mutable: bool) -> *const QualifiedType {
        let _type: *const QualifiedType = new QualifiedType(LLVMPointerType(pointee->Value(), 0u32), mutable, true, false, pointee);
        this.types.PushBack(_type);
        ret _type;
    }

    pub Array(&mut this, pointee: *const QualifiedType, size: u64, mutable: bool) -> *const QualifiedType {
        let _type: *const QualifiedType = new QualifiedType(LLVMArrayType2(pointee->Value(), size), mutable, size, false, pointee);
        this.types.PushBack(_type);
        ret _type;
    }

    pub Copy(&mut this, _type: *mut QualifiedType, mutable: bool) -> *const QualifiedType {
        if mutable != _type->IsMutable() {
            let mut copy: *mut QualifiedType = null;

            if _type->IsPointer() {
                copy = new QualifiedType(_type->Value(), mutable, _type->IsReference(), false, _type->Pointee());
                (copy->byval, copy->sret) = (_type->byval, _type->sret);
            } else {
                Logger::Log("TypeManager", "Cannot copy non-pointer type.", LogSeverity::Error);
                ret null;
            }

            this.types.PushBack(copy);
            ret copy;
        } else {
            ret _type;
        }
    }
}

class QualifiedValue {
    priv value: LLVMValueRef = null, priv _type: *const QualifiedType = null,
    pub instance: LLVMValueRef = null, pub instance_type: *const QualifiedType = null,
    pub binding: bool = false, pub return: bool = false;

    QualifiedValue(&mut this, value: LLVMValueRef, _type: *const QualifiedType) {
        (this.value, this._type) = (value, _type);
    }

    QualifiedValue(&mut this, value: LLVMValueRef, _type: *const QualifiedType, instance: &QualifiedValue) {
        (this.value, this._type, this.instance, this.instance_type) = (value, _type, instance.value, instance._type);
    }

    QualifiedValue(&mut this, value: LLVMValueRef, _type: *const QualifiedType, return: bool, binding: bool) {
        (this.value, this._type, this.return, this.binding) = (value, _type, return, binding);
    }

    QualifiedValue(&mut this, value: LLVMValueRef, _type: *const QualifiedType, return: bool) {
        (this.value, this._type, this.return) = (value, _type, return);
    }

    ~QualifiedValue(&this) {}

    pub Null(&this) -> bool {
        ret this.value == null;
    }

    pub Value(&this) -> LLVMValueRef {
        if this.value != null {
            ret this.value;
        } else {
            Logger::Log("QualifiedValue", "Null value!", LogSeverity::Error);
            ret null;
        }
    }

    pub Type(&this) -> &QualifiedType {
        if this._type != null {
            ret this._type;
        } else {
            Logger::Log("QualifiedValue", "Null type!", LogSeverity::Error);
            ret null;
        }
    }
}

enum SymbolKind: i32 {
    Variable, GlobalVariable, Constant, Function, Parameter, Generic, Class, Type
}

func ToString(kind: SymbolKind) -> String {
    if kind == SymbolKind::Variable { ret "Variable".ToString(); }
    else if kind == SymbolKind::GlobalVariable { ret "GlobalVariable".ToString(); }
    else if kind == SymbolKind::Constant { ret "Constant".ToString(); }
    else if kind == SymbolKind::Function { ret "Function".ToString(); }
    else if kind == SymbolKind::Parameter { ret "Parameter".ToString(); }
    else if kind == SymbolKind::Generic { ret "Generic".ToString(); }
    else if kind == SymbolKind::Class { ret "Class".ToString(); }
    else if kind == SymbolKind::Type { ret "Type".ToString(); }
    else { ret "Unknown".ToString(); }
}

class Symbol {
    pub name: String,
    pub kind: SymbolKind,
    pub value: QualifiedValue,
    pub pointer: *const void = null;

    Symbol(&mut this, name: String, kind: SymbolKind, value: QualifiedValue) {
        (this.name, this.kind, this.value) = (name, kind, value);
    }

    Symbol(&mut this, name: String, kind: SymbolKind, pointer: *const void) {
        (this.name, this.kind, this.pointer) = (name, kind, pointer);
    }

    ~Symbol(&this) {}
}

class Scope {
    pub parent: *const Scope,
    pub children: Vector<*const Scope>,
    pub name: String, pub global: bool,
    pub symbols: Vector<*const Symbol>,
    pub instances: Vector<QualifiedValue>;

    Scope(&mut this, parent: *const Scope, name: &String, global: bool) {
        (this.parent, this.name, this.global) = (parent, name, global);
    }

    ~Scope(&this) {
        let mut i: u64 = 0u64;

        while i < this.symbols.Size() {
            del this.symbols[i];
            i += 1u64;
        }
    }

    pub Has(&this, name: &String) -> bool {
        let mut i: u64 = 0u64;

        while i < this.symbols.Size() {
            if this.symbols[i]->name == name {
                ret true;
            } i += 1u64;
        } ret false;
    }
    
    pub Has(&this, name: &String, kind: SymbolKind) -> bool {
        let mut i: u64 = 0u64;

        while i < this.symbols.Size() {
            if this.symbols[i]->name == name && this.symbols[i]->kind == kind {
                ret true;
            } i += 1u64;
        } ret false;
    }

    pub Set(&mut this, name: &String, kind: SymbolKind, value: &QualifiedValue, overload: bool, node: *const ASTNode) -> *const Symbol {
        if this.Has(name) && !overload {
            Logger::Log("Symbol '" + name + "' already exists.", node, LogSeverity::Error);
            ret null;
        } else {
            let symbol: *const Symbol = new Symbol(name, kind, value);
            this.symbols.PushBack(symbol);
            ret symbol;
        }
    }

    pub Set(&mut this, name: &String, kind: SymbolKind, pointer: *const void, overload: bool, node: *const ASTNode) -> *const Symbol {
        if this.Has(name) && !overload {
            Logger::Log("Symbol '" + name + "' already exists.", node, LogSeverity::Error);
            ret null;
        } else {
            let symbol: *const Symbol = new Symbol(name, kind, pointer);
            this.symbols.PushBack(symbol);
            ret symbol;
        }
    }

    pub Get(&this, name: &String) -> *const Symbol {
        let mut i: u64 = 0u64;

        while i < this.symbols.Size() {
            if this.symbols[i]->name == name {
                ret this.symbols[i];
            } i += 1u64;
        } ret null;
    }

    pub Get(&this, name: &String, kind: SymbolKind) -> *const Symbol {
        let mut i: u64 = 0u64;

        while i < this.symbols.Size() {
            if this.symbols[i]->name == name && this.symbols[i]->kind == kind {
                ret this.symbols[i];
            } i += 1u64;
        } ret null;
    }

    pub GetAll(&this, name: &String) -> Vector<*const Symbol> {
        let mut result: Vector<*const Symbol>;
        let mut i: u64 = 0u64;

        while i < this.symbols.Size() {
            if this.symbols[i]->name == name {
                result.PushBack(this.symbols[i]);
            } i += 1u64;
        } ret result;
    }

    pub GetAll(&this, name: &String, kind: SymbolKind) -> Vector<*const Symbol> {
        let mut result: Vector<*const Symbol>;
        let mut i: u64 = 0u64;

        while i < this.symbols.Size() {
            if this.symbols[i]->name == name && this.symbols[i]->kind == kind {
                result.PushBack(this.symbols[i]);
            } i += 1u64;
        } ret result;
    }
}

class ScopeManager {
    pub CompileType: func(*const void, *const ASTNode) -> &QualifiedType,
    pub CompileDestructor2: func(*const void, LLVMValueRef, *const QualifiedType),

    pub compiler: *const void = null, pub builder: LLVMBuilderRef = null,
    pub scopes: Vector<*const Scope>, pub current: *mut Scope = null;

    ScopeManager(&mut this) {
        this.PushScope(String("global"), true);
    }

    ~ScopeManager(&mut this) {
        this.PopScope();
    }

    pub PushScope(&mut this, name: String, global: bool) {
        let scope: *mut Scope = new Scope(this.current, name, global);

        if global {
            this.scopes.PushBack(scope);
        }

        if this.current != null {
            this.current->children.PushBack(scope);
        } this.current = scope;
    }

    pub PopScope(&mut this) {
        if this.current != null {
            let temp: *const Scope = this.current;
            this.current = this.current->parent;
            let mut i: u64 = 0u64;

            if this.current == null {
                while i < this.scopes.Size() {
                    del this.scopes[i];
                    i += 1u64;
                }
            } else if !temp->global {
                while i < temp->instances.Size() {
                    let instance: QualifiedValue = temp->instances[i];

                    if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
                        this.CompileDestructor2(this.compiler, instance.Value(), &instance.Type());
                    } i += 1u64;
                }

                this.current->children.Remove(temp);
                del temp;
            }
        } else {
            Logger::Log("ScopeManager", "No scope to pop.", LogSeverity::Error);
        }
    }

    pub RegisterInstance(&mut this, instance: QualifiedValue) {
        if !this.current->global {
            this.current->instances.PushBack(instance);
        } else {
            Logger::Log("ScopeManager", "Cannot register instance in global scope.", LogSeverity::Error);
            ret;
        }
    }

    pub InvokeDestructors(&this, except: QualifiedValue) {
        let mut scope: *const Scope = this.current;

        while !scope->global {
            let mut i: u64 = 0u64;

            while i < scope->instances.Size() {
                let instance: QualifiedValue = scope->instances[i];

                if instance != except {
                    this.CompileDestructor2(this.compiler, instance.Value(), &instance.Type());
                } i += 1u64;
            } scope = scope->parent;
        }
    }

    pub InvokeDestructors(&this) {
        let mut scope: *const Scope = this.current;

        while !scope->global {
            let mut i: u64 = 0u64;

            while i < scope->instances.Size() {
                let instance: QualifiedValue = scope->instances[i];
                this.CompileDestructor2(this.compiler, instance.Value(), &instance.Type());
                i += 1u64;
            } scope = scope->parent;
        }
    }

    pub Has(&this, name: String) -> bool {
        let mut scope: *const Scope = this.current;

        while scope != null {
            if scope->Has(name) {
                ret true;
            } else {
                scope = scope->parent;
            }
        } ret false;
    }

    pub Has(&this, name: String, kind: SymbolKind) -> bool {
        let mut scope: *const Scope = this.current;

        while scope != null {
            if scope->Has(name, kind) {
                ret true;
            } else {
                scope = scope->parent;
            }
        } ret false;
    }

    pub Set(&mut this, name: String, kind: SymbolKind, value: QualifiedValue, overload: bool, node: *const ASTNode) -> *const Symbol {
        ret this.current->Set(name, kind, value, overload, node);
    }

    pub Set(&mut this, name: String, kind: SymbolKind, pointer: *const void, overload: bool, node: *const ASTNode) -> *const Symbol {
        ret this.current->Set(name, kind, pointer, overload, node);
    }

    pub Get(&this, name: String) -> *const Symbol {
        let mut scope: *const Scope = this.current;

        while scope != null {
            if scope->Has(name) {
                ret scope->Get(name);
            } else {
                scope = scope->parent;
            }
        } ret null;
    }

    pub Get(&this, name: String, kind: SymbolKind) -> *const Symbol {
        let mut scope: *const Scope = this.current;

        while scope != null {
            if scope->Has(name, kind) {
                ret scope->Get(name, kind);
            } else {
                scope = scope->parent;
            }
        } ret null;
    }

    pub GetAll(&this, name: String) -> Vector<*const Symbol> {
        let mut result: Vector<*const Symbol>;
        let mut scope: *const Scope = this.current;

        while scope != null {
            if scope->Has(name) {
                result += scope->GetAll(name);
            } scope = scope->parent;
        } ret result;
    }

    pub GetAll(&this, name: String, kind: SymbolKind) -> Vector<*const Symbol> {
        let mut result: Vector<*const Symbol>;
        let mut scope: *const Scope = this.current;

        while scope != null {
            if scope->Has(name, kind) {
                result += scope->GetAll(name, kind);
            } scope = scope->parent;
        } ret result;
    }

    pub Namespaces(&this) -> Vector<String> {
        let mut scope: *const Scope = this.current;
        let mut inverse: Vector<String>;

        while scope->parent != null {
            if scope->global {
                inverse.PushBack(scope->name);
            } scope = scope->parent;
        }

        let mut result: Vector<String>;
        let mut i: u64 = inverse.Size();

        while i > 0u64 {
            result.PushBack(inverse[i - 1u64]);
            i -= 1u64;
        } ret result;
    }

    pub ResolveChild(&this, scope: *const Scope, identifier: *const IdentifierNode, test: bool) -> *const Scope {
        let mut i: u64 = 0u64;

        while i < scope->children.Size() {
            if scope->children[i]->name == identifier->name {
                ret scope->children[i];
            } else {
                i += 1u64;
            }
        }

        if !test {
            Logger::Log("Scope '" + identifier->name + "' not found.", identifier as *const ASTNode, LogSeverity::Error);
        } ret null;
    }

    pub ResolveChild(&this, scope: *const Scope, primitive_type: *const PrimitiveTypeNode, test: bool) -> *const Scope {
        if primitive_type->generic {
            if scope->Has(primitive_type->name) {
                let mut types: Vector<*const QualifiedType>;
                let mut i: u64 = 0u64;

                while i < primitive_type->types.Size() {
                    types.PushBack(this.CompileType(this.compiler, primitive_type->types[i]));
                    i += 1u64;
                }

                ret (scope->Get(primitive_type->name)->pointer as *mut Generic)->Get(types).right;
            } else if !test {
                Logger::Log("Generic '" + primitive_type->name + "' not found.", primitive_type as *const ASTNode, LogSeverity::Error);
            } ret null;
        } else {
            let mut i: u64 = 0u64;

            while i < scope->children.Size() {
                if scope->children[i]->name == primitive_type->name {
                    ret scope->children[i];
                } else {
                    i += 1u64;
                }
            }

            if !test {
                Logger::Log("Scope '" + primitive_type->name + "' not found.", primitive_type as *const ASTNode, LogSeverity::Error);
            } ret null;
        }
    }

    pub ResolveScopeHalf(&this, resolution: *const ScopeResolutionNode, test: bool) -> *const Scope {
        let mut scope: *const Scope = this.current;

        while !scope->global {
            scope = scope->parent;
        }

        if resolution->scope != null {
            if resolution->scope->node_type == ASTNodeType::SCOPE_RESOLUTION {
                scope = this.ResolveScopeFull(resolution->scope as *const ScopeResolutionNode, test);
            } else if resolution->scope->node_type == ASTNodeType::PRIMITIVE_TYPE {
                scope = this.ResolveChild(scope, resolution->scope as *const PrimitiveTypeNode, test);
            } else if resolution->scope->node_type == ASTNodeType::IDENTIFIER {
                scope = this.ResolveChild(scope, resolution->scope as *const IdentifierNode, test);
            } else {
                if !test {
                    Logger::Log("Unknown resolution '" + resolution->scope->node_type.ToString() + "'.", resolution->scope, LogSeverity::Error);
                } ret null;
            }
        } else {
            while scope->parent != null {
                scope = scope->parent;
            }
        } ret scope;
    }

    pub ResolveScopeFull(&this, resolution: *const ScopeResolutionNode, test: bool) -> *const Scope {
        ret this.ResolveChild(this.ResolveScopeHalf(resolution, test), resolution->identifier, test);
    }

    pub Resolve(&this, resolution: *const ScopeResolutionNode, test: bool) -> *const Symbol {
        let scope: *const Scope = this.ResolveScopeHalf(resolution, test);

        if scope == null {
            ret null;
        }

        if scope->Has(resolution->identifier->name) {
            ret scope->Get(resolution->identifier->name);
        } else {
            if !test {
                Logger::Log("Symbol '" + resolution->identifier->name + "' not found.", resolution as *const ASTNode, LogSeverity::Error);
            } ret null;
        }
    }

    pub Resolve(&this, identifier: *const IdentifierNode, test: bool) -> *const Symbol {
        if this.Has(identifier->name) {
            ret this.Get(identifier->name);
        } else {
            if !test {
                Logger::Log("Symbol '" + identifier->name + "' not found.", identifier as *const ASTNode, LogSeverity::Error);
            } ret null;
        }
    }

    pub Resolve(&this, node: *const ASTNode, test: bool) -> *const Symbol {
        if node->node_type == ASTNodeType::SCOPE_RESOLUTION {
            ret this.Resolve(node as *const ScopeResolutionNode, test);
        } else if node->node_type == ASTNodeType::IDENTIFIER {
            ret this.Resolve(node as *const IdentifierNode, test);
        } else {
            if !test {
                Logger::Log("Unknown resolution '" + node->node_type.ToString() + "'.", node, LogSeverity::Error);
            } ret null;
        }
    }

    pub Resolve(&this, name: &String, node: *const ASTNode, test: bool) -> *const Symbol {
        if this.Has(name) {
            ret this.Get(name);
        } else {
            if !test {
                Logger::Log("Symbol '" + name + "' not found.", node, LogSeverity::Error);
            } ret null;
        }
    }

    pub Resolve(&this, symbols: &Vector<*const Symbol>, params: &Vector<*const QualifiedType>, node: *const ASTNode, test: bool) -> *const Symbol {
        let (mut index: u64, mut best: u64, mut i: u64) = (0u64, 0u64, 0u64);

        while i < symbols.Size() {
            let (mut _match: bool, mut score: u64, mut j: u64) = (true, 1u64, 0u64);
            let _params: &Vector<*const QualifiedType> = symbols[i]->value.Type().Pointee().Parameters();
            let mut offset: u64 = 0u64;

            if _params.Size() != 0u64 {
                offset = _params[0u64]->sret != null ? 1u64 : 0u64;
            }

            if params.Size() != _params.Size() - offset {
                i += 1u64;
                continue;
            }

            while params.Size() > j {
                let mut _type: *const QualifiedType = _params[j + offset];

                if _type->byval != null {
                    _type = _type->byval;
                }

                if _type->IsReference() && *_type != *(params[j]) {
                    _type = _type->Pointee();
                }

                let (mut _state: bool, mut state_: bool) = (false, false);

                if params[j]->IsReference() {
                    if *_type == params[j]->Pointee() {
                        _state = true;
                    } else if _type->IsPointer() && params[j]->Pointee().IsPointer() {
                        if LLVMGetTypeKind(_type->Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || params[j]->Pointee().Pointee()._null {
                            state_ = true;
                        }
                    }
                }

                if _type->IsPointer() && params[j]->IsPointer() {
                    if LLVMGetTypeKind(_type->Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || params[j]->Pointee()._null {
                        state_ = true;
                    }
                }

                if *_type == *(params[j]) || _state || state_ {
                    score += _state ? 3u64 : (state_ ? 1u64 : 2u64);
                } else {
                    _match = false;
                    break;
                } j += 1u64;
            }

            if _match && score > best {
                (index, best) = (i, score);
            } i += 1u64;
        }

        if best != 0u64 {
            ret symbols[index];
        } else {
            if !test {
                Logger::Log("Invalid arguments for: '" + symbols[0u64]->name + "'.", node, LogSeverity::Error);
            } ret null;
        }
    }

    pub Resolve(&this, resolution: *const ScopeResolutionNode, params: &Vector<*const QualifiedType>, test: bool) -> *const Symbol {
        let scope: *const Scope = this.ResolveScopeHalf(resolution, test);

        if scope->Has(resolution->identifier->name, SymbolKind::Function) {
            ret this.Resolve(scope->GetAll(resolution->identifier->name, SymbolKind::Function), params, resolution as *const ASTNode, test);
        } else {
            if !test {
                Logger::Log("Symbol '" + resolution->identifier->name + "' not found.", resolution as *const ASTNode, LogSeverity::Error);
            } ret null;
        }
    }

    pub Resolve(&this, identifier: *const IdentifierNode, params: &Vector<*const QualifiedType>, test: bool) -> *const Symbol {
        if this.Has(identifier->name, SymbolKind::Function) {
            ret this.Resolve(this.GetAll(identifier->name, SymbolKind::Function), params, identifier as *const ASTNode, test);
        } else {
            if !test {
                Logger::Log("Symbol '" + identifier->name + "' not found.", identifier as *const ASTNode, LogSeverity::Error);
            } ret null;
        }
    }

    pub Resolve(&this, node: *const ASTNode, params: &Vector<*const QualifiedType>, test: bool) -> *const Symbol {
        if node->node_type == ASTNodeType::SCOPE_RESOLUTION {
            ret this.Resolve(node as *const ScopeResolutionNode, params, test);
        } else if node->node_type == ASTNodeType::IDENTIFIER {
            ret this.Resolve(node as *const IdentifierNode, params, test);
        } else {
            if !test {
                Logger::Log("Unknown resolution '" + node->node_type.ToString() + "'.", node, LogSeverity::Error);
            } ret null;
        }
    }

    pub Resolve(&this, name: &String, params: &Vector<*const QualifiedType>, node: *const ASTNode, test: bool) -> *const Symbol {
        if this.Has(name, SymbolKind::Function) {
            ret this.Resolve(this.GetAll(name, SymbolKind::Function), params, node, test);
        } else {
            if !test {
                Logger::Log("Symbol '" + name + "' not found.", node, LogSeverity::Error);
            } ret null;
        }
    }
}

class Mangler {
    pub prefix: *const i8 = "$d",
    pub scope_manager: *const ScopeManager = null;

    Mangler(&mut this) {}
    ~Mangler(&mut this) {}

    priv MangleType(&this, _type: *const QualifiedType) -> String {
        if _type->byval != null { ret this.MangleType(_type->byval); }
        if _type->sret != null { ret this.MangleType(_type->sret); }
        let kind: LLVMTypeKind = LLVMGetTypeKind(_type->Value());

        if kind == LLVMTypeKind::LLVMVoidTypeKind {
            ret String("v");
        } else if kind == LLVMTypeKind::LLVMPointerTypeKind {
            ret "P" + this.MangleType(_type->Pointee());
        } else if kind == LLVMTypeKind::LLVMFunctionTypeKind {
            let mut result: String = "F";
            result += this.MangleType(_type->Return());
            let params: Vector<*const QualifiedType> = _type->Parameters();
            let mut i: u64 = 0u64;

            while i < params.Size() {
                result += this.MangleType(params[i]);
                i += 1u64;
            } ret result;
        } else if kind == LLVMTypeKind::LLVMStructTypeKind {
            let mut name: String = LLVMGetStructName(_type->Value());

            if name[0u64] != '$' || name[1u64] != 'd' {
                name = this.MangleClass(name);
            } ret String(name.Data() + 2u64);
        } else if kind == LLVMTypeKind::LLVMIntegerTypeKind {
            let width: u32 = LLVMGetIntTypeWidth(_type->Value());
            ret String(width == 1u32 ? "b" : (width == 8u32 ? "c" : (width == 16u32 ? "s" : (width == 32u32 ? "i" : "l"))));
        } else if kind == LLVMTypeKind::LLVMDoubleTypeKind {
            ret String("d");
        } else if kind == LLVMTypeKind::LLVMFloatTypeKind {
            ret String("f");
        } else {
            Logger::Log("Mangler", "Unknown type '" + LLVMTypeToString(_type->Value()) + "'.", LogSeverity::Error);
            ret String("");
        }
    }

    priv MangleName(&this, name: String) -> String {
        if this.scope_manager == null {
            Logger::Log("Mangler", "Scope manager not set!", LogSeverity::Error);
            ret String("");
        }

        let mut result: String = this.prefix;
        let mut names: Vector<String> = this.scope_manager->Namespaces();
        names.PushBack(name);

        if names.Size() > 1u64 {
            result += "N";
        }

        let mut i: u64 = 0u64;

        while i < names.Size() {
            result += String(names[i].Size() as i64) + names[i];
            i += 1u64;
        }

        if names.Size() > 1u64 {
            result += "E";
        } ret result;
    }

    pub MangleFunction(&this, name: String, _type: *const QualifiedType) -> String {
        let mut result: String = this.MangleName(name);
        let params: Vector<*const QualifiedType> = _type->Parameters();
        let mut i: u64 = 0u64;

        while i < params.Size() {
            result += this.MangleType(params[i]);
            i += 1u64;
        } ret result;
    }

    pub MangleClass(&this, name: String) -> String {
        ret this.MangleName(name);
    }

    pub MangleClass(&this, name: String, types: Vector<*const QualifiedType>) -> String {
        let mut result: String = this.MangleName(name);

        if !types.Empty() {
            result += "I";
        }

        let mut i: u64 = 0u64;

        while i < types.Size() {
            result += this.MangleType(types[i]);
            i += 1u64;
        }

        if !types.Empty() {
            result += "E";
        } ret result;
    }
}

class Generic {
    pub CompileClass: func(*const void, *const ClassDeclNode, *const Generic) -> *const QualifiedType,
    pub CompileEnum2: func(*const void, *mut EnumDeclNode, *mut Generic) -> *const QualifiedType,

    priv compiler: *const void, priv mangler: *const Mangler, priv scope_manager: *mut ScopeManager,
    priv current_generic: *mut *const Generic, pub ast: *const ASTNode, pub scope: *mut Scope,
    priv cache: Map<String, Pair<*const QualifiedType, *mut Scope>>,

    pub name: String, pub type_names: Vector<String>,
    pub symbols: Vector<*const Symbol>, pub last_scope: *mut Scope = null,
    pub current: String, pub types: Vector<*const QualifiedType>;

    Generic(&mut this, compiler: *const void, ast: *mut ASTNode, mangler: *const Mangler, scope_manager: *const ScopeManager, current_generic: *const *const Generic) {
        (this.compiler, this.mangler, this.scope_manager) = (compiler, mangler, scope_manager);
        (this.current_generic, this.ast, this.scope) = (current_generic, ast, this.scope_manager->current);

        if ast->node_type != ASTNodeType::CLASS_DECL {
            let enum_decl: *const EnumDeclNode = ast as *const EnumDeclNode;
            (this.name, this.type_names) = (enum_decl->name, enum_decl->types);
        } else {
            let class_decl: *const ClassDeclNode = ast as *const ClassDeclNode;
            (this.name, this.type_names) = (class_decl->name, class_decl->types);
        }
    }

    ~Generic(&this) {}

    pub Set(&mut this, _class: *const QualifiedType) {
        if this.current != "" {
            let mut i: u64 = 0u64;

            while i < this.type_names.Size() {
                this.symbols.PushBack(this.scope_manager->Set(this.type_names[i], SymbolKind::Type, QualifiedValue(null, this.types[i]), false, this.ast));
                i += 1u64;
            }

            this.last_scope = this.scope_manager->current;
            this.cache[this.current] = Pair<*const QualifiedType, *mut Scope>(_class, this.last_scope);
            this.current = "";
        } else {
            Logger::Log("Generic", "Not in a generic compilation.", LogSeverity::Error);
            ret;
        }
    }

    pub Get(&mut this, types: Vector<*const QualifiedType>) -> Pair<*const QualifiedType, *mut Scope> {
        let prev_generic: *const Generic = *this.current_generic;
        *this.current_generic = this;
        let scope: *const Scope = this.scope_manager->current;
        this.scope_manager->current = this.scope;

        if this.current != "" {
            Logger::Log("Generic", "Nested generics are not supported.", LogSeverity::Error);
        }

        if types.Size() != this.type_names.Size() {
            Logger::Log("Generic", "Generic type parameter count mismatch.", LogSeverity::Error);
        }

        let name: String = this.mangler->MangleClass(this.name, types);

        if this.cache.Has(name) {
            this.scope_manager->current = scope;
            *this.current_generic = prev_generic;
            ret this.cache[name];
        } else {
            this.current = name;
            this.types = types;
        }

        let mut temp: *mut Generic = this;
        let mut _class: *const QualifiedType = null;

        if this.ast->node_type != ASTNodeType::CLASS_DECL {
            _class = this.CompileEnum2(this.compiler, this.ast as *const EnumDeclNode, temp);
        } else {
            _class = this.CompileClass(this.compiler, this.ast as *const ClassDeclNode, temp);
        }

        let mut i: u64 = 0u64;

        while i < this.symbols.Size() {
            let index: i64 = this.last_scope->symbols.Index(this.symbols[i]);

            if index != -1i64 {
                this.last_scope->symbols.RemoveAt(index as u64);
            } else {
                Logger::Log("Generic", "Failed to remove temporary generic type '" + this.symbols[i]->name + "' from scope.", LogSeverity::Error);
            } i += 1u64;
        }

        this.types.Clear();
        this.symbols.Clear();
        (this.scope_manager->current, *this.current_generic) = (scope, prev_generic);
        ret Pair<*const QualifiedType, *mut Scope>(_class, this.last_scope);
    }
}

class Forward {
    pub _class: *const QualifiedType,
    pub generic: *const Generic = null,
    pub types: Vector<*const QualifiedType>,
    pub decl: *const FunctionDeclNode,
    pub _type: *const QualifiedType,
    pub value: LLVMValueRef;

    Forward(&mut this, decl: *const FunctionDeclNode, _type: *const QualifiedType, value: LLVMValueRef, _class: *const QualifiedType) {
        (this.decl, this._type, this.value, this._class) = (decl, _type, value, _class);
    }

    Forward(&mut this, decl: *const FunctionDeclNode, _type: *const QualifiedType, value: LLVMValueRef, _class: *const QualifiedType, types: &Vector<*const QualifiedType>, generic: *const Generic) {
        (this.decl, this._type, this.value, this._class, this.types, this.generic) = (decl, _type, value, _class, types, generic);
    }

    ~Forward(&this) {}
}

class Compiler {
    priv mangler: Mangler,
    priv mangling: bool = true,
    priv generics: Vector<*const Generic>,
    priv type_manager: TypeManager,
    priv generic: *const Generic = null,
    priv _class: *const QualifiedType = null,
    priv function: *const QualifiedType = null,
    priv function_ref: LLVMValueRef = null,
    priv scope_manager: ScopeManager,
    priv blocks: Vector<Pair<LLVMBasicBlockRef, LLVMBasicBlockRef>>,
    priv forwards: Vector<Forward>,
    pub target_machine: LLVMTargetMachineRef = null,
    priv layout: LLVMTargetDataRef = null,
    priv context: LLVMContextRef = null,
    priv module: LLVMModuleRef = null,
    priv builder: LLVMBuilderRef = null,
    priv triple: String, priv march: String,
    priv target: LLVMTargetRef = null,
    priv systemv: bool = false;

    Compiler(&mut this, triple: String, march: String, opt_level: LLVMCodeGenOptLevel) {
        LLVMInitializeNativeTarget();
        LLVMInitializeNativeAsmPrinter();
        LLVMInitializeNativeAsmParser();
        LLVMInitializeNativeDisassembler();
        this.context = LLVMContextCreate();

        (this.triple, this.march) = (triple, march);
        if this.triple.Empty() { this.triple = LLVMGetDefaultTargetTriple(); }
        if this.march == "native" { this.march = LLVMGetHostCPUName(); }
        if this.march.Empty() { this.march = "generic"; }
        let message: *const i8 = null;

        if LLVMGetTargetFromTriple(this.triple.Data(), &this.target, &message) != 0i32 {
            WriteLine("\x1b[31mFailed to get target from triple: " + message.ToString() + ".\x1b[0m");
            LLVMDisposeMessage(message);
            ret;
        }

        LLVMDisposeMessage(message);
        this.target_machine = LLVMCreateTargetMachine(this.target, this.triple.Data(), this.march.Data(), "", opt_level, LLVMRelocMode::LLVMRelocDefault, LLVMCodeModel::LLVMCodeModelDefault);
        this.layout = LLVMCreateTargetDataLayout(this.target_machine);
        this.systemv = !this.triple.Contains("windows");

        this.scope_manager.compiler = this as *const void;
        this.scope_manager.CompileType = Compiler::CompileType;
        this.scope_manager.CompileDestructor2 = Compiler::CompileDestructor2;
        this.mangler.scope_manager = &this.scope_manager;
    }

    ~Compiler(&mut this) {
        this.mangler.scope_manager = null;
        this.scope_manager.CompileDestructor2 = null;
        this.scope_manager.CompileType = null;
        this.scope_manager.compiler = null;

        if this.builder != null {
            LLVMDisposeBuilder(this.builder);
            this.builder = null;
        }

        if this.module != null {
            LLVMDisposeModule(this.module);
            this.module = null;
        }

        LLVMDisposeTargetMachine(this.target_machine);
        LLVMContextDispose(this.context);
    }

    pub Forget(&mut this) {
        this.module = null;
    }

    pub Compile(&mut this, ast: *const RootNode, file_name: &String) -> LLVMModuleRef {
        if this.builder != null {
            LLVMDisposeBuilder(this.builder);
            this.builder = null;
        }

        if this.module != null {
            LLVMDisposeModule(this.module);
            this.module = null;
        }

        this.module = LLVMModuleCreateWithNameInContext("divine", this.context);
        this.builder = LLVMCreateBuilderInContext(this.context);
        this.scope_manager.builder = this.builder;
        LLVMSetSourceFileName(this.module, file_name.Data(), file_name.Length());
        LLVMSetTarget(this.module, this.triple.Data());
        let layout: *const i8 = LLVMCopyStringRepOfTargetData(this.layout);
        LLVMSetDataLayout(this.module, layout);
        LLVMDisposeMessage(layout);
        let mut i: u64 = 0u64;

        while i < ast->declarations.Size() {
            this.CompileDeclaration(ast->declarations[i]);
            i += 1u64;
        }

        this.CompileForwardDeclarations();
        let mut j: u64 = 0u64;

        while j < this.generics.Size() {
            del this.generics[j];
            j += 1u64;
        }

        this.generics.Clear();
        this.forwards.Clear();
        let message: *const i8 = null;

        if LLVMVerifyModule(this.module, LLVMVerifierFailureAction::LLVMAbortProcessAction, &message) != 0i32 {
            WriteLine("\x1b[31mModule verification failed: " + message.ToString() + ".\x1b[0m");
            LLVMDisposeMessage(message);
            ret null;
        }

        LLVMDisposeMessage(message);
        this.scope_manager.builder = null;
        ret this.module;
    }

    priv CompileForwardDeclarations(&mut this) {
        let mut i: u64 = 0u64;

        while i < this.forwards.Size() {
            let forward: Forward = this.forwards[i];
            (this.function, this.function_ref) = (forward._type, forward.value);
            let has_instance: bool = forward.decl->_type->instance_kind != InstanceKind::None;
            let params: Vector<*const QualifiedType> = this.function->Parameters();
            let scope: *const Scope = this.scope_manager.current;
            this._class = forward._class;

            if forward.generic != null {
                this.scope_manager.current = forward.generic->scope;
            }

            let mut j: u64 = 0u64;
            let mut symbols: Vector<*const Symbol>;

            while j < forward.types.Size() {
                symbols.PushBack(forward.generic->scope->Set(forward.generic->type_names[j], SymbolKind::Type, QualifiedValue(null, forward.types[j]), false, forward.decl as *const ASTNode));
                j += 1u64;
            }

            this.scope_manager.PushScope(forward.decl->name, false);
            let entry: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, this.function_ref, "");
            LLVMPositionBuilderAtEnd(this.builder, entry);
            let mut k: u64 = 0u64;

            while (has_instance && k == 0u64) || k < forward.decl->_type->parameters.Size() + (has_instance ? 1u64 : 0u64) {
                let (mut name: String, mut mutable: bool);

                if has_instance && k == 0u64 {
                    (name, mutable) = ("this", false);
                } else {
                    let index: u64 = has_instance ? k - 1u64 : k;
                    let param: *const ParameterNode = forward.decl->_type->parameters[index];
                    (name, mutable) = (param->name, param->mutable);
                }

                let index: u64 = params[0u64]->sret != null ? k + 1u64 : k;
                let mut _type: *const QualifiedType = params[index];

                if params[index]->byval != null && LLVMGetTypeKind(_type->Value()) == LLVMTypeKind::LLVMPointerTypeKind {
                    _type = this.type_manager.Pointer(params[index]->byval, mutable);
                    let instance: QualifiedValue = QualifiedValue(LLVMGetParam(this.function_ref, index as u32), _type, false, true);
                    this.scope_manager.Set(name, SymbolKind::Parameter, instance, false, forward.decl as *const ASTNode);
                    if _type->Pointee().IsClass() { this.scope_manager.RegisterInstance(instance); }
                } else {
                    if params[index]->byval != null { _type = params[index]->byval; }
                    let current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
                    LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(LLVMGetBasicBlockParent(current)));
                    let pointer: LLVMValueRef = LLVMBuildAlloca(this.builder, _type->Value(), "");

                    LLVMPositionBuilderAtEnd(this.builder, current);
                    LLVMBuildStore(this.builder, LLVMGetParam(this.function_ref, index as u32), pointer);
                    let instance: QualifiedValue = QualifiedValue(pointer, this.type_manager.Pointer(_type, mutable), false, true);
                    if params[index]->byval != null && _type->IsClass() { this.scope_manager.RegisterInstance(instance); }
                    this.scope_manager.Set(name, SymbolKind::Parameter, instance, false, forward.decl as *const ASTNode);
                } k += 1u64;
            }

            let mut l: u64 = 0u64;

            while forward.decl->constructors.Size() > l {
                let _class: &QualifiedType = this.CompileType(forward.decl->constructors[l]->expression);

                if !_class.IsClass() {
                    Logger::Log("Constructor type must be a class.", forward.decl as *const ASTNode, LogSeverity::Error);
                    ret;
                }

                let mut values: Vector<QualifiedValue>;
                let mut m: u64 = 0u64;

                while forward.decl->constructors[l]->arguments.Size() > m {
                    let value: QualifiedValue = this.CompileExpression(forward.decl->constructors[l]->arguments[m], false);

                    if !value.Null() {
                        values.PushBack(value);
                    } else {
                        ret;
                    } m += 1u64;
                }

                let index: u64 = params[0u64]->sret != null ? 1u64 : 0u64;
                let instance: QualifiedValue = QualifiedValue(LLVMGetParam(this.function_ref, index as u32), params[index]);
                this.CompileConstructor(_class, this.CompileCast2(instance, this.type_manager.Pointer(_class, _class.IsMutable()), forward.decl as *const ASTNode), values, forward.decl as *const ASTNode);
                l += 1u64;
            }

            this.CompileBlock(forward.decl->body);
            this.scope_manager.PopScope();

            if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
                let mut state: bool = true;

                if LLVMGetTypeKind(this.function->Return().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                    if !params.Empty() {
                        state = params[0u64]->sret != null;
                    } else {
                        state = false;
                    }
                }

                if !state {
                    LLVMBuildRetVoid(this.builder);
                } else {
                    Logger::Log("Function '" + forward.decl->name + "' must return a value.", forward.decl as *const ASTNode, LogSeverity::Error);
                    ret;
                }
            }

            let mut m: u64 = 0u64;

            while m < symbols.Size() {
                let index: i64 = forward.generic->scope->symbols.Index(symbols[m]);

                if index != -1i64 {
                    forward.generic->scope->symbols.RemoveAt(index as u64);
                    del symbols[m];
                } m += 1u64;
            }

            if forward.generic != null {
                this.scope_manager.current = scope;
            }

            this.function = null;
            this.function_ref = null;
            this._class = null;
            i += 1u64;
        }
    }

    priv CompileDeclaration(&mut this, decl: *const ASTNode) {
        if decl->node_type == ASTNodeType::CONSTANT_DECL {
            this.CompileConstant(decl as *const ConstantDeclNode);
        } else if decl->node_type == ASTNodeType::STATIC_DECL {
            this.CompileStatic(decl as *const StaticDeclNode);
        } else if decl->node_type == ASTNodeType::FUNCTION_DECL {
            this.CompileFunction(decl as *const FunctionDeclNode);
        } else if decl->node_type == ASTNodeType::CLASS_DECL {
            this.CompileClass(decl as *const ClassDeclNode, null);
        } else if decl->node_type == ASTNodeType::ENUM_DECL {
            this.CompileEnum(decl as *const EnumDeclNode, null);
        } else if decl->node_type == ASTNodeType::EXTERN_BLOCK {
            this.CompileExtern(decl as *const ExternBlockNode);
        } else if decl->node_type == ASTNodeType::TYPE_DECL {
            let type_decl: *const TypeDeclNode = decl as *const TypeDeclNode;
            this.scope_manager.Set(type_decl->name, SymbolKind::Type, QualifiedValue(null, this.CompileType(type_decl->_type)), false, decl);
        } else if decl->node_type == ASTNodeType::INLINE_ASM {
            this.CompileInlineAsm(decl as *const InlineAsmNode);
        } else {
            Logger::Log("Unknown declaration '" + decl->node_type.ToString() + "'.", decl, LogSeverity::Error);
        }
    }

    priv CompileConstant(&mut this, constant_decl: *const ConstantDeclNode) {
        let mut initializer: QualifiedValue;
        let mut _type: *mut QualifiedType = this.CompileType(constant_decl->_type);
        let mut has_error: bool = false;

        if constant_decl->initializer->node_type != ASTNodeType::INITIALIZER_LIST {
            initializer = this.CompileExpression(constant_decl->initializer, false);
            if initializer.Null() { has_error = true; }
        } else {
            let mut values: Vector<LLVMValueRef>;
            let initializer_list: *const InitializerListNode = constant_decl->initializer as *const InitializerListNode;

            if _type->IsPointer() {
                _type = this.type_manager.Array(_type->Pointee(), initializer_list->expressions.Size(), _type->IsMutable());
            }

            if _type->IsClass() {
                let fields: &mut Map<String, Pair<Field, *const QualifiedType>> = _type->Fields();
                let mut i: u64 = 0u64;

                while i < fields.Size() {
                    if i < initializer_list->expressions.Size() {
                        let value: QualifiedValue = this.CompileExpression(initializer_list->expressions[i], false);

                        if !value.Null() {
                            values.PushBack(value.Value());
                        } else {
                            has_error = true;
                            break;
                        }
                    } else {
                        if fields[i].right.left.initializer != null {
                            let value: QualifiedValue = this.CompileExpression(fields[i].right.left.initializer, false);

                            if !value.Null() {
                                values.PushBack(value.Value());
                            } else {
                                has_error = true;
                                break;
                            }
                        } else {
                            Logger::Log("Missing initializer for field '" + fields[i].left + "'.", constant_decl as *const ASTNode, LogSeverity::Error);
                            has_error = true;
                            break;
                        }
                    } i += 1u64;
                }

                if !has_error {
                    initializer = QualifiedValue(LLVMConstNamedStruct(_type->Value(), values.Data(), values.Size() as u32), _type);
                }
            } else if _type->IsArray() {
                if initializer_list->expressions.Size() != _type->Size() {
                    Logger::Log("Incompatible initializer list size. ('" + String(_type->Size() as i64) + "' != '" + String(initializer_list->expressions.Size() as i64) + "').", constant_decl as *const ASTNode, LogSeverity::Error);
                    has_error = true;
                }

                let mut i: u64 = 0u64;

                while i < initializer_list->expressions.Size() && !has_error {
                    let value: QualifiedValue = this.CompileExpression(initializer_list->expressions[i], false);

                    if value.Null() {
                        has_error = true;
                        break;
                    }

                    let mut state: bool = false;

                    if value.Type().IsPointer() && _type->Element().IsPointer() {
                        if LLVMGetTypeKind(value.Type().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(_type->Element().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                            state = true;
                        }
                    }

                    if value.Type() != _type->Element() && !state {
                        Logger::Log("Incompatible initializer list element types. ('" + LLVMTypeToString(value.Type().Value()) + "' != '" + LLVMTypeToString(_type->Element().Value()) + "').", constant_decl as *const ASTNode, LogSeverity::Error);
                        has_error = true;
                        break;
                    }

                    values.PushBack(value.Value());
                    i += 1u64;
                }

                if !has_error {
                    initializer = QualifiedValue(LLVMConstArray2(_type->Value(), values.Data(), values.Size()), _type);
                }
            } else {
                Logger::Log("Invalid type '" + LLVMTypeToString(_type->Value()) + "' for initializer list.", constant_decl as *const ASTNode, LogSeverity::Error);
                has_error = true;
            }
        }

        if has_error {
            this.scope_manager.Set(constant_decl->name, SymbolKind::GlobalVariable, QualifiedValue(null, null), false, constant_decl as *const ASTNode);
            ret;
        }

        let mut state: bool = false;

        if initializer.Type().IsPointer() && _type->IsPointer() {
            if LLVMGetTypeKind(initializer.Type().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(_type->Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                state = true;
            }
        }

        if initializer.Type() != *_type && !state {
            Logger::Log("Incompatible constant initialization types. ('" + LLVMTypeToString(_type->Value()) + "' != '" + LLVMTypeToString(initializer.Type().Value()) + "').", constant_decl as *const ASTNode, LogSeverity::Error);
            ret;
        }

        let global: LLVMValueRef = LLVMAddGlobal(this.module, _type->Value(), constant_decl->name.Data());
        this.scope_manager.Set(constant_decl->name, SymbolKind::GlobalVariable, QualifiedValue(global, this.type_manager.Pointer(_type, false), false, true), false, constant_decl as *const ASTNode);
        LLVMSetLinkage(global, LLVMLinkage::LLVMPrivateLinkage);
        LLVMSetInitializer(global, initializer.Value());
        LLVMSetGlobalConstant(global, 1i32);
    }

    priv CompileStatic(&mut this, static_decl: *const StaticDeclNode) {
        let mut initializer: QualifiedValue;
        let mut _type: *mut QualifiedType = this.CompileType(static_decl->_type);
        let mut has_error: bool = false;

        if static_decl->initializer != null {
            if static_decl->initializer->node_type != ASTNodeType::INITIALIZER_LIST {
                initializer = this.CompileExpression(static_decl->initializer, false);
                if initializer.Null() { has_error = true; }
            } else {
                let mut values: Vector<LLVMValueRef>;
                let initializer_list: *const InitializerListNode = static_decl->initializer as *const InitializerListNode;

                if _type->IsPointer() {
                    _type = this.type_manager.Array(_type->Pointee(), initializer_list->expressions.Size(), _type->IsMutable());
                }

                if _type->IsClass() {
                    let fields: &mut Map<String, Pair<Field, *const QualifiedType>> = _type->Fields();
                    let mut i: u64 = 0u64;

                    while i < fields.Size() {
                        if i < initializer_list->expressions.Size() {
                            let value: QualifiedValue = this.CompileExpression(initializer_list->expressions[i], false);

                            if !value.Null() {
                                values.PushBack(value.Value());
                            } else {
                                has_error = true;
                                break;
                            }
                        } else {
                            if fields[i].right.left.initializer != null {
                                let value: QualifiedValue = this.CompileExpression(fields[i].right.left.initializer, false);

                                if !value.Null() {
                                    values.PushBack(value.Value());
                                } else {
                                    has_error = true;
                                    break;
                                }
                            } else {
                                Logger::Log("Missing initializer for field '" + fields[i].left + "'.", static_decl as *const ASTNode, LogSeverity::Error);
                                has_error = true;
                                break;
                            }
                        } i += 1u64;
                    }

                    if !has_error {
                        initializer = QualifiedValue(LLVMConstNamedStruct(_type->Value(), values.Data(), values.Size() as u32), _type);
                    }
                } else if _type->IsArray() {
                    if initializer_list->expressions.Size() != _type->Size() {
                        Logger::Log("Incompatible initializer list size. ('" + String(_type->Size() as i64) + "' != '" + String(initializer_list->expressions.Size() as i64) + "').", static_decl as *const ASTNode, LogSeverity::Error);
                        has_error = true;
                    }

                    let mut i: u64 = 0u64;

                    while i < initializer_list->expressions.Size() && !has_error {
                        let value: QualifiedValue = this.CompileExpression(initializer_list->expressions[i], false);

                        if value.Null() {
                            has_error = true;
                            break;
                        }

                        let mut state: bool = false;

                        if value.Type().IsPointer() && _type->Element().IsPointer() {
                            if LLVMGetTypeKind(value.Type().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(_type->Element().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                                state = true;
                            }
                        }

                        if value.Type() != _type->Element() && !state {
                            Logger::Log("Incompatible initializer list element types. ('" + LLVMTypeToString(value.Type().Value()) + "' != '" + LLVMTypeToString(_type->Element().Value()) + "').", static_decl as *const ASTNode, LogSeverity::Error);
                            has_error = true;
                            break;
                        }

                        values.PushBack(value.Value());
                        i += 1u64;
                    }

                    if !has_error {
                        initializer = QualifiedValue(LLVMConstArray2(_type->Value(), values.Data(), values.Size()), _type);
                    }
                } else {
                    Logger::Log("Invalid type '" + LLVMTypeToString(_type->Value()) + "' for initializer list.", static_decl as *const ASTNode, LogSeverity::Error);
                    has_error = true;
                }
            }

            if !has_error {
                let mut state: bool = false;

                if initializer.Type().IsPointer() && _type->IsPointer() {
                    if LLVMGetTypeKind(initializer.Type().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(_type->Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                        state = true;
                    }
                }

                if initializer.Type() != *_type && !state {
                    Logger::Log("Incompatible constant initialization types. ('" + LLVMTypeToString(_type->Value()) + "' != '" + LLVMTypeToString(initializer.Type().Value()) + "').", static_decl as *const ASTNode, LogSeverity::Error);
                    has_error = true;
                }
            }
        }

        if has_error {
            this.scope_manager.Set(static_decl->name, SymbolKind::Variable, QualifiedValue(null, null), false, static_decl as *const ASTNode);
            ret;
        }

        let global: LLVMValueRef = LLVMAddGlobal(this.module, _type->Value(), static_decl->name.Data());
        this.scope_manager.Set(static_decl->name, SymbolKind::Variable, QualifiedValue(global, this.type_manager.Pointer(_type, static_decl->mutable), false, true), false, static_decl as *const ASTNode);
        LLVMSetLinkage(global, this.mangling ? LLVMLinkage::LLVMInternalLinkage : LLVMLinkage::LLVMExternalLinkage);
        LLVMSetGlobalConstant(global, static_decl->mutable ? 0i32 : 1i32);

        if !initializer.Null() {
            LLVMSetInitializer(global, initializer.Value());
        }
    }

    priv ProcessType(&mut this, _type: *const QualifiedType) -> *const QualifiedType {
        if LLVMGetTypeKind(_type->Value()) != LLVMTypeKind::LLVMStructTypeKind {
            ret _type;
        } else {
            let size: u64 = LLVMABISizeOfType(this.layout, _type->Value());

            if size > 8u64 {
                ret this.type_manager.Pointer(_type, _type->IsMutable());
            } else {
                if size > 4u64 {
                    ret this.type_manager.Primitive(LLVMInt64TypeInContext(this.context), true);
                } else if size > 2u64 {
                    ret this.type_manager.Primitive(LLVMInt32TypeInContext(this.context), true);
                } else if size > 1u64 {
                    ret this.type_manager.Primitive(LLVMInt16TypeInContext(this.context), true);
                } else {
                    ret this.type_manager.Primitive(LLVMInt8TypeInContext(this.context), true);
                }
            }
        }
    }

    priv CompileFunction(&mut this, func_decl: *const FunctionDeclNode) -> QualifiedValue {
        if func_decl->generic {
            Logger::Log("Generic functions are not supported yet.", func_decl as *const ASTNode, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }

        let (mut params: Vector<*const QualifiedType>, mut param_types: Vector<LLVMTypeRef>);
        let mut return_type: *const QualifiedType = this.CompileType(func_decl->_type->return_type);
        let mut attributes: Vector<LLVMTypeRef>;
        let mut sret: bool = false;

        if LLVMGetTypeKind(return_type->Value()) == LLVMTypeKind::LLVMStructTypeKind && !return_type->IsEnum() {
            let processed_type: &mut QualifiedType = this.ProcessType(return_type);
            processed_type.sret = return_type;

            if LLVMGetTypeKind(processed_type.Value()) != LLVMTypeKind::LLVMPointerTypeKind {
                return_type = processed_type;
            } else {
                params.PushBack(processed_type);
                param_types.PushBack(processed_type.Value());
                attributes.PushBack(return_type->Value());
                return_type = this.type_manager.Primitive(LLVMVoidTypeInContext(this.context), false);
                sret = true;
            }
        }

        let mut instance_type: *const QualifiedType = null;

        if func_decl->_type->instance_kind != InstanceKind::None {
            if this._class == null {
                Logger::Log("Instance parameters are only allowed in class and enum methods.", func_decl as *const ASTNode, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            if func_decl->_type->instance_kind == InstanceKind::ConstRef || func_decl->_type->instance_kind == InstanceKind::MutRef {
                instance_type = this.type_manager.Reference(this._class, func_decl->_type->instance_kind == InstanceKind::MutRef);
            } else if func_decl->_type->instance_kind == InstanceKind::Copy {
                instance_type = this._class;
            }
        }

        let mut i: u64 = 0u64;

        while instance_type != null || i < func_decl->_type->parameters.Size() {
            let mut real_type: *const QualifiedType;

            if instance_type != null {
                (real_type, instance_type) = (instance_type, null);
            } else {
                real_type = this.CompileType(func_decl->_type->parameters[i]->param_type);
                i += 1u64;
            }

            let processed_type: &mut QualifiedType = real_type->IsEnum() ? real_type : this.ProcessType(real_type);
            param_types.PushBack(processed_type.Value());
            params.PushBack(processed_type);

            if (*real_type) != processed_type {
                attributes.PushBack(LLVMGetTypeKind(processed_type.Value()) == LLVMTypeKind::LLVMPointerTypeKind ? real_type->Value() : null);
                processed_type.byval = real_type;
            } else {
                attributes.PushBack(null);
            }
        }

        let mut name: String = func_decl->name;
        let type_ref: LLVMTypeRef = LLVMFunctionType(return_type->Value(), param_types.Data(), param_types.Size() as u32, func_decl->_type->var_arg ? 1i32 : 0i32);
        let _type: &mut QualifiedType = this.type_manager.Function(type_ref, params, return_type);
        let mangling: bool = this.mangling && name != "main";
        _type.name = name;

        if mangling {
            name = this.mangler.MangleFunction(func_decl->name, _type);
        }

        let function: LLVMValueRef = LLVMAddFunction(this.module, name.Data(), _type.Value());
        let value: QualifiedValue = QualifiedValue(function, this.type_manager.Pointer(_type, false));
        this.scope_manager.Set(func_decl->name, SymbolKind::Function, value, mangling, func_decl as *const ASTNode);
        let mut j: u64 = 0u64;

        while j < attributes.Size() {
            if attributes[j] != null {
                let attribute_kind: u32 = sret && j == 0u64 ? LLVMGetEnumAttributeKindForName("sret", 4u64) : LLVMGetEnumAttributeKindForName("byval", 5u64);
                LLVMAddAttributeAtIndex(function, (j + 1u64) as u32, LLVMCreateTypeAttribute(this.context, attribute_kind, attributes[j]));
            } j += 1u64;
        }

        let attribute_name: String = "no-stack-arg-probe";
        let attribute: LLVMAttributeRef = LLVMCreateStringAttribute(this.context, attribute_name.Data(), attribute_name.Length() as u32, "", 0u32);
        LLVMAddAttributeAtIndex(function, LLVMAttributeIndex::LLVMAttributeFunctionIndex, attribute);

        if this._class == null && !func_decl->constructors.Empty() {
            Logger::Log("Constructors can only be declared inside classes.", func_decl as *const ASTNode, LogSeverity::Error);
            ret value;
        }

        let mut k: u64 = 0u64;

        while func_decl->constructors.Size() > k {
            let _class: &mut QualifiedType = this.CompileType(func_decl->constructors[k]->expression);

            if !_class.IsClass() {
                Logger::Log("Constructor type must be a class.", func_decl as *const ASTNode, LogSeverity::Error);
                ret value;
            }

            _class.constructed.PushBack(this._class);
            k += 1u64;
        }

        if func_decl->body != null {
            if this.generic != null {
                this.forwards.PushBack(Forward(func_decl, _type, function, this._class, this.generic->types, this.generic));
            } else {
                this.forwards.PushBack(Forward(func_decl, _type, function, this._class));
            }
        } ret value;
    }

    priv ValueToType(&mut this, values: Vector<QualifiedValue>) -> Vector<*const QualifiedType> {
        let mut result: Vector<*const QualifiedType>;
        let mut i: u64 = 0u64;

        while i < values.Size() {
            result.PushBack(values[i].Type());
            i += 1u64;
        } ret result;
    }

    priv CompileConstructor(&mut this, _class: &QualifiedType, pointer: QualifiedValue, params: Vector<QualifiedValue>, node: *const ASTNode) {
        let mut need_copy: bool = false;

        if params.Size() == 1u64 {
            if params[0u64].Type().IsPointer() {
                need_copy = params[0u64].Type().Pointee() == _class;
            }
        }

        let param_types: Vector<*const QualifiedType> = this.ValueToType(params);
        let has_constructor: bool = _class.Has(_class.name, param_types, this._class);
        let (mut is_constructed: bool, mut i: u64) = (false, 0u64);

        while i < _class.constructed.Size() && this._class != null {
            let constructed: &QualifiedType = _class.constructed[i];

            if (*this._class) != constructed {
                i += 1u64;
            } else {
                is_constructed = true;
                break;
            }
        }

        let mut j: u64 = 0u64;
        let fields: &mut Map<String, Pair<Field, *const QualifiedType>> = _class.Fields();

        while j < fields.Size() {
            let field: &mut Pair<String, Pair<Field, *const QualifiedType>> = fields[j];
            let mut value: QualifiedValue = QualifiedValue(null, field.right.right);

            if !(has_constructor && !is_constructed) && j < params.Size() {
                value = params[j];
            } else {
                if field.right.left.initializer != null {
                    if field.right.left.initializer->node_type != ASTNodeType::INITIALIZER_LIST {
                        value = this.CompileExpression(field.right.left.initializer, false);
                        if value.Null() { ret; }
                    }
                }
            }

            if need_copy && !(has_constructor && !is_constructed) {
                value = QualifiedValue(LLVMBuildStructGEP2(this.builder, params[0u64].Type().Pointee().Value(), params[0u64].Value(), _class.Index(field.left) as u32, ""), this.type_manager.Pointer(field.right.right, true));
            }

            if field.right.right->IsClass() {
                let mut _params: Vector<QualifiedValue>;

                if !value.Null() {
                    if value.Type().IsClass() {
                        value = QualifiedValue(LLVMAddressOf(value.Value(), this.builder), this.type_manager.Pointer(value.Type(), true));
                    } _params.PushBack(value);
                } else {
                    if field.right.left.initializer != null {
                        if field.right.left.initializer->node_type == ASTNodeType::INITIALIZER_LIST {
                            let initializer_list: *const InitializerListNode = field.right.left.initializer as *const InitializerListNode;
                            let mut i: u64 = 0u64;

                            while i < initializer_list->expressions.Size() {
                                let value: QualifiedValue = this.CompileExpression(initializer_list->expressions[i], false);
                                if value.Null() { ret; }
                                _params.PushBack(value);
                                i += 1u64;
                            }
                        }
                    }
                }

                this.CompileConstructor(field.right.right, QualifiedValue(LLVMBuildStructGEP2(this.builder, pointer.Type().Pointee().Value(), pointer.Value(), _class.Index(field.left) as u32, ""), this.type_manager.Pointer(field.right.right, true)), _params, node);
            } else if !value.Null() {
                if value.Type().IsPointer() {
                    let pointee: &QualifiedType = value.Type().Pointee();

                    if pointee == field.right.right {
                        value = QualifiedValue(LLVMBuildLoad2(this.builder, pointee.Value(), value.Value(), ""), pointee);
                    }
                }

                this.CompileAssignment2(value, QualifiedValue(LLVMBuildStructGEP2(this.builder, pointer.Type().Pointee().Value(), pointer.Value(), _class.Index(field.left) as u32, ""), this.type_manager.Pointer(field.right.right, true)), TokenType::ASSIGN, true, node);
            } j += 1u64;
        }

        if has_constructor && !is_constructed {
            let param_types: Vector<*const QualifiedType> = this.ValueToType(params);

            if _class.Has(_class.name, param_types, this._class) {
                let method: &Pair<Method, *const QualifiedType> = _class.Get(_class.name, param_types, this._class, node);
                this.CompileCall2(QualifiedValue(method.left.value, method.right, pointer), params, false, true, node);
            } else {
                Logger::Log("Class doesn't have compatible constructor.", node, LogSeverity::Error);
            }
        } else {
            if params.Size() > fields.Size() {
                Logger::Log("Too many parameters.", node, LogSeverity::Error);
            }
        }
    }

    priv CompileDestructor(&mut this, _class: &QualifiedType, pointer: QualifiedValue, node: *const ASTNode) {
        let (params: Vector<QualifiedValue>, params_types: Vector<*const QualifiedType>);

        if _class.Has("~" + _class.name, params_types, this._class) {
            let method: &Pair<Method, *const QualifiedType> = _class.Get("~" + _class.name, params_types, this._class, node);
            this.CompileCall2(QualifiedValue(method.left.value, method.right, pointer), params, false, true, node);
        }

        let fields: &mut Map<String, Pair<Field, *const QualifiedType>> = _class.Fields();
        let mut i: u64 = 0u64;

        while i < fields.Size() {
            let field: &mut Pair<String, Pair<Field, *const QualifiedType>> = fields[i];

            if field.right.right->IsClass() {
                this.CompileDestructor(field.right.right, QualifiedValue(LLVMBuildStructGEP2(this.builder, pointer.Type().Pointee().Value(), pointer.Value(), _class.Index(field.left) as u32, ""), this.type_manager.Pointer(field.right.right, true)), node);
            } i += 1u64;
        }
    }

    priv CompileDestructor2(&mut this, value: LLVMValueRef, _type: *const QualifiedType) {
        this.CompileDestructor(_type->Pointee(), QualifiedValue(value, _type), null);
    }

    priv CompileClass(&mut this, class_decl: *const ClassDeclNode, generic: *mut Generic) -> *const QualifiedType {
        if class_decl->generic && generic == null {
            let _generic: *mut Generic = new Generic(this as *const void, class_decl as *const ASTNode, &this.mangler, &this.scope_manager, &this.generic);
            _generic->CompileClass = Compiler::CompileClass;
            this.scope_manager.Set(class_decl->name, SymbolKind::Generic, _generic as *const void, false, class_decl as *const ASTNode);
            this.generics.PushBack(_generic);
            ret null;
        }

        let mut struct_name: *const i8 = generic != null ? generic->current.Data() : class_decl->name.Data();
        let _class: &mut QualifiedType = this.type_manager.Class(LLVMStructCreateNamed(this.context, struct_name), class_decl->name);

        if generic != null {
            this.scope_manager.PushScope(generic->current, true);
            generic->Set(_class);
        } else {
            this.scope_manager.Set(class_decl->name, SymbolKind::Class, QualifiedValue(null, _class), false, class_decl as *const ASTNode);
            this.scope_manager.PushScope(class_decl->name, true);
        }

        let mut field_types: Vector<LLVMTypeRef>;
        let (mut i: u64, mut j: u64) = (0u64, 0u64);

        while i < class_decl->parents.Size() {
            let _type: &QualifiedType = this.CompileType(class_decl->parents[i]);
            _class.fields[_type.name] = Pair<Field, *const QualifiedType>(Field(null, TokenType::PRIVATE, i), _type);
            field_types.PushBack(_type.Value());
            i += 1u64;
        }

        while j < class_decl->fields.Size() {
            let field: &Pair<TokenType, *const FieldNode> = class_decl->fields[j];
            let field_type: &QualifiedType = this.CompileType(field.right->field_type);
            _class.fields[field.right->name] = Pair<Field, *const QualifiedType>(Field(field.right->initializer, field.left, i + j), field_type);
            field_types.PushBack(field_type.Value());
            j += 1u64;
        }

        let prev_class: *const QualifiedType = this._class;
        this._class = _class;

        if !field_types.Empty() {
            LLVMStructSetBody(_class.Value(), field_types.Data(), field_types.Size() as u32, 0i32);
        }

        let (mut k: u64, mut l: u64) = (0u64, 0u64);

        while k < class_decl->constructors.Size() {
            let method: QualifiedValue = this.CompileFunction(class_decl->constructors[k]);
            _class.methods.PushBack(Pair<Method, *const QualifiedType>(Method(class_decl->constructors[k]->name, method.Value(), TokenType::PUBLIC), method.Type()));
            k += 1u64;
        }

        if class_decl->destructor != null {
            let method: QualifiedValue = this.CompileFunction(class_decl->destructor);
            _class.methods.PushBack(Pair<Method, *const QualifiedType>(Method(class_decl->destructor->name, method.Value(), TokenType::PUBLIC), method.Type()));
        }

        while l < class_decl->methods.Size() {
            let method: QualifiedValue = this.CompileFunction(class_decl->methods[l].right);
            _class.methods.PushBack(Pair<Method, *const QualifiedType>(Method(class_decl->methods[l].right->name, method.Value(), class_decl->methods[l].left), method.Type()));
            l += 1u64;
        }

        this.scope_manager.PopScope();
        this._class = prev_class;
        ret _class;
    }

    priv CompileEnum(&mut this, enum_decl: *mut EnumDeclNode, generic: *mut Generic) -> *const QualifiedType {
        if enum_decl->generic && generic == null {
            let _generic: *mut Generic = new Generic(this as *const void, enum_decl as *const ASTNode, &this.mangler, &this.scope_manager, &this.generic);
            _generic->CompileEnum2 = Compiler::CompileEnum;
            this.scope_manager.Set(enum_decl->name, SymbolKind::Generic, _generic as *const void, false, enum_decl as *const ASTNode);
            this.generics.PushBack(_generic);
            ret null;
        }

        let mut is_adt: bool = false;
        let mut i: u64 = 0u64;

        while i < enum_decl->variants.Size() {
            if !enum_decl->variants[i]->types.Empty() {
                is_adt = true;
                break;
            } i += 1u64;
        }

        if is_adt {
            let mut struct_name: *const i8 = generic != null ? generic->current.Data() : enum_decl->name.Data();
            let struct_type: LLVMTypeRef = LLVMStructCreateNamed(this.context, struct_name);
            let _enum: &mut QualifiedType = this.type_manager.Enum(struct_type, enum_decl->name);

            if generic != null {
                this.scope_manager.PushScope(generic->current, true);
                generic->Set(_enum);
            } else {
                this.scope_manager.Set(enum_decl->name, SymbolKind::Class, QualifiedValue(null, _enum), false, enum_decl as *const ASTNode);
                this.scope_manager.PushScope(enum_decl->name, true);
            }

            let mut max_size: u64 = 0u64;
            let mut variant_types: Vector<Pair<String, Vector<*const QualifiedType>>>;
            let mut i: u64 = 0u64;

            while i < enum_decl->variants.Size() {
                let mut types: Vector<*const QualifiedType>;
                let mut j: u64 = 0u64;

                while j < enum_decl->variants[i]->types.Size() {
                    let _type: &QualifiedType = this.CompileType(enum_decl->variants[i]->types[j]);
                    types.PushBack(_type);
                    j += 1u64;
                }

                variant_types.PushBack(Pair<String, Vector<*const QualifiedType>>(enum_decl->variants[i]->name, types));
                let current_size: u64 = LLVMABISizeOfType(this.layout, this.CreateVariantPayloadType(types));

                if current_size > max_size {
                    max_size = current_size;
                } i += 1u64;
            }

            _enum.variants = variant_types;
            let tag_type: LLVMTypeRef = LLVMInt32TypeInContext(this.context);
            let data_type: LLVMTypeRef = LLVMArrayType(LLVMInt8TypeInContext(this.context), max_size as u32);
            let elements[]: LLVMTypeRef = { tag_type, data_type };
            LLVMStructSetBody(struct_type, elements, 2u32, 0i32);
            let mut j: u64 = 0u64;

            while j < enum_decl->variants.Size() {
                _enum.variant_field_names.PushBack(enum_decl->variants[j]->field_names);
                j += 1u64;
            }

            let mut k: u64 = 0u64;

            while k < enum_decl->variants.Size() {
                let variant: *const VariantNode = enum_decl->variants[k];
                let current_variant_types: Vector<*const QualifiedType> = variant_types[k].right;

                if current_variant_types.Empty() {
                    let tag_value: LLVMValueRef = LLVMConstInt(tag_type, k, 0i32);
                    let data_value: LLVMValueRef = LLVMConstNull(data_type);
                    let values[]: LLVMValueRef = { tag_value, data_value };
                    let const_val: LLVMValueRef = LLVMConstNamedStruct(struct_type, values, 2u32);
                    this.scope_manager.Set(variant->name, SymbolKind::Constant, QualifiedValue(const_val, _enum), false, enum_decl as *const ASTNode);
                } else {
                    let mut param_types: Vector<LLVMTypeRef>;
                    let mut l: u64 = 0u64;

                    while l < current_variant_types.Size() {
                        param_types.PushBack(current_variant_types[l]->Value());
                        l += 1u64;
                    }

                    let func_type: LLVMTypeRef = LLVMFunctionType(struct_type, param_types.Data(), param_types.Size() as u32, 0i32);
                    let func_name: String = this.mangler.MangleFunction(variant->name, this.type_manager.Function(func_type, current_variant_types, _enum));
                    let function: LLVMValueRef = LLVMAddFunction(this.module, func_name.Data(), func_type);

                    let entry: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "entry");
                    let temp_builder: LLVMBuilderRef = LLVMCreateBuilderInContext(this.context);
                    LLVMPositionBuilderAtEnd(temp_builder, entry);

                    let mut alloca: LLVMValueRef = LLVMBuildAlloca(temp_builder, struct_type, "adt");
                    let tag_ptr: LLVMValueRef = LLVMBuildStructGEP2(temp_builder, struct_type, alloca, 0u32, "tag_ptr");
                    LLVMBuildStore(temp_builder, LLVMConstInt(tag_type, k, 0i32), tag_ptr);

                    let data_ptr: LLVMValueRef = LLVMBuildStructGEP2(temp_builder, struct_type, alloca, 1u32, "data_ptr");
                    let payload_type: LLVMTypeRef = this.CreateVariantPayloadType(current_variant_types);
                    let payload_ptr: LLVMValueRef = LLVMBuildBitCast(temp_builder, data_ptr, LLVMPointerType(payload_type, 0u32), "payload_ptr");
                    let mut m: u64 = 0u64;

                    while m < current_variant_types.Size() {
                        let param: LLVMValueRef = LLVMGetParam(function, m as u32);
                        let elem_ptr: LLVMValueRef = LLVMBuildStructGEP2(temp_builder, payload_type, payload_ptr, m as u32, "");
                        LLVMBuildStore(temp_builder, param, elem_ptr);
                        m += 1u64;
                    }

                    LLVMBuildRet(temp_builder, LLVMBuildLoad2(temp_builder, struct_type, alloca, ""));
                    LLVMDisposeBuilder(temp_builder);
                    
                    this.scope_manager.Set(variant->name, SymbolKind::Function, QualifiedValue(function, this.type_manager.Pointer(this.type_manager.Function(func_type, current_variant_types, _enum), false)), false, enum_decl as *const ASTNode);
                } k += 1u64;
            }

            if !enum_decl->methods.Empty() {
                let prev_class: *const QualifiedType = this._class;
                this._class = _enum;
                this.scope_manager.PushScope(enum_decl->name, true);
                let mut l: u64 = 0u64;

                while l < enum_decl->methods.Size() {
                    let method: QualifiedValue = this.CompileFunction(enum_decl->methods[l].right);
                    _enum.methods.PushBack(Pair<Method, *const QualifiedType>(Method(enum_decl->methods[l].right->name, method.Value(), enum_decl->methods[l].left), method.Type()));
                    l += 1u64;
                }

                this.scope_manager.PopScope();
                this._class = prev_class;
            }

            this.scope_manager.PopScope();
            ret _enum;
        } else {
            let underlying_type: &QualifiedType = this.CompileType(enum_decl->underlying_type);

            if LLVMGetTypeKind(underlying_type.Value()) != LLVMTypeKind::LLVMIntegerTypeKind {
                Logger::Log("Expected an integer type.", enum_decl as *const ASTNode, LogSeverity::Error);
                ret null;
            }

            this.scope_manager.Set(enum_decl->name, SymbolKind::Type, QualifiedValue(null, underlying_type), false, enum_decl as *const ASTNode);
            let mut value: LLVMValueRef = LLVMConstInt(underlying_type.Value(), 0u64, underlying_type.IsSigned() ? 1i32 : 0i32);
            this.scope_manager.PushScope(enum_decl->name, true);
            let mut has_error: bool = false;
            let mut i: u64 = 0u64;

            while i < enum_decl->variants.Size() {
                if enum_decl->variants[i]->value != null {
                    let _value: QualifiedValue = this.CompileExpression(enum_decl->variants[i]->value, false);

                    if !_value.Null() {
                        if _value.Type() == underlying_type {
                            value = _value.Value();
                        } else {
                            Logger::Log("Incompatible enum value types. ('" + LLVMTypeToString(_value.Type().Value()) + "' != '" + LLVMTypeToString(underlying_type.Value()) + "').", enum_decl as *const ASTNode, LogSeverity::Error);
                            has_error = true;
                        }
                    } else {
                        has_error = true;
                    }
                }

                if !has_error {
                    this.scope_manager.Set(enum_decl->variants[i]->name, SymbolKind::Constant, QualifiedValue(value, underlying_type), false, enum_decl as *const ASTNode);
                    value = LLVMConstAdd(value, LLVMConstInt(underlying_type.Value(), 1u64, underlying_type.IsSigned() ? 1i32 : 0i32));
                } else {
                    this.scope_manager.Set(enum_decl->variants[i]->name, SymbolKind::Constant, QualifiedValue(null, null), false, enum_decl as *const ASTNode);
                } i += 1u64;
            }

            this.scope_manager.PopScope();
            ret null;
        }
    }

    priv CreateVariantPayloadType(&mut this, types: Vector<*const QualifiedType>) -> LLVMTypeRef {
        if types.Empty() {
            ret LLVMStructTypeInContext(this.context, null, 0u32, 0i32);
        }

        let mut elements: *mut LLVMTypeRef = new LLVMTypeRef[types.Size()];
        let mut i: u64 = 0u64;

        while i < types.Size() {
            elements[i] = types[i]->Value();
            i += 1u64;
        }

        let payload_type: LLVMTypeRef = LLVMStructTypeInContext(this.context, elements, types.Size() as u32, 0i32);
        del[] elements;
        ret payload_type;
    }

    priv VariantIndex(&this, _enum: *const QualifiedType, name: &String) -> i64 {
        let mut i: u64 = 0u64;

        while i < _enum->variants.Size() {
            if _enum->variants[i].left == name {
                ret i as i64;
            } i += 1u64;
        } ret -1i64;
    }

    priv VariantFieldIndex(&this, _enum: *const QualifiedType, variant_index: u64, name: &String) -> i64 {
        let mut i: u64 = 0u64;
        let names: &Vector<String> = _enum->variant_field_names[variant_index];

        while i < names.Size() {
            if names[i] == name {
                ret i as i64;
            } i += 1u64;
        } ret -1i64;
    }

    priv PatternIsWildcard(&this, pattern: *const ASTNode) -> bool {
        if pattern == null || pattern->node_type != ASTNodeType::IDENTIFIER {
            ret false;
        }

        ret (pattern as *const IdentifierNode)->name == "_";
    }

    priv BuildEnumTagPointer(&mut this, pointer: LLVMValueRef, _type: *const QualifiedType) -> LLVMValueRef {
        ret LLVMBuildStructGEP2(this.builder, _type->Value(), pointer, 0u32, "tag_ptr");
    }

    priv BuildPayloadFieldPointer(&mut this, pointer: LLVMValueRef, _enum: *const QualifiedType, variant_index: u64, field_index: u64) -> LLVMValueRef {
        let data_ptr: LLVMValueRef = LLVMBuildStructGEP2(this.builder, _enum->Value(), pointer, 1u32, "data_ptr");
        let payload_type: LLVMTypeRef = this.CreateVariantPayloadType(_enum->variants[variant_index].right);
        let payload_ptr: LLVMValueRef = LLVMBuildBitCast(this.builder, data_ptr, LLVMPointerType(payload_type, 0u32), "payload_ptr");
        ret LLVMBuildStructGEP2(this.builder, payload_type, payload_ptr, field_index as u32, "payload_field_ptr");
    }

    priv BuildPatternCondition(&mut this, pattern: *const ASTNode, pointer: LLVMValueRef, _type: *const QualifiedType) -> LLVMValueRef {
        if this.PatternIsWildcard(pattern) {
            ret LLVMConstInt(LLVMInt1TypeInContext(this.context), 1u64, 0i32);
        }

        if pattern->node_type == ASTNodeType::OR_PATTERN {
            let or_pattern: *const OrPatternNode = pattern as *const OrPatternNode;
            let left: LLVMValueRef = this.BuildPatternCondition(or_pattern->left, pointer, _type);
            let right: LLVMValueRef = this.BuildPatternCondition(or_pattern->right, pointer, _type);
            ret LLVMBuildOr(this.builder, left, right, "or_pattern");
        }

        if _type->IsEnum() {
            let mut variant_name: String;
            let mut arguments: Vector<*const ASTNode>;
            let mut is_struct_pattern: bool = false;
            let mut struct_field_names: Vector<String>;

            if pattern->node_type == ASTNodeType::CALL {
                let call: *const CallNode = pattern as *const CallNode;
                arguments = call->arguments;

                if call->expression->node_type == ASTNodeType::IDENTIFIER {
                    variant_name = (call->expression as *const IdentifierNode)->name;
                } else if call->expression->node_type == ASTNodeType::SCOPE_RESOLUTION {
                    variant_name = (call->expression as *const ScopeResolutionNode)->identifier->name;
                } else {
                    Logger::Log("Invalid enum pattern.", pattern, LogSeverity::Error);
                    ret null;
                }
            } else if pattern->node_type == ASTNodeType::STRUCT_INIT {
                let si: *const StructInitNode = pattern as *const StructInitNode;
                is_struct_pattern = true;
                struct_field_names = si->field_names;
                arguments = si->field_values;

                if si->expression->node_type == ASTNodeType::IDENTIFIER {
                    variant_name = (si->expression as *const IdentifierNode)->name;
                } else if si->expression->node_type == ASTNodeType::SCOPE_RESOLUTION {
                    variant_name = (si->expression as *const ScopeResolutionNode)->identifier->name;
                } else {
                    Logger::Log("Invalid enum struct pattern.", pattern, LogSeverity::Error);
                    ret null;
                }
            } else if pattern->node_type == ASTNodeType::IDENTIFIER {
                variant_name = (pattern as *const IdentifierNode)->name;
            } else if pattern->node_type == ASTNodeType::SCOPE_RESOLUTION {
                variant_name = (pattern as *const ScopeResolutionNode)->identifier->name;
            } else {
                Logger::Log("Invalid enum pattern.", pattern, LogSeverity::Error);
                ret null;
            }

            let variant_index: i64 = this.VariantIndex(_type, &variant_name);

            if variant_index == -1i64 {
                Logger::Log("Unknown enum variant '" + variant_name + "'.", pattern, LogSeverity::Error);
                ret null;
            }

            let variant_types: Vector<*const QualifiedType> = _type->variants[variant_index as u64].right;

            if !is_struct_pattern && arguments.Size() != variant_types.Size() {
                Logger::Log("Pattern argument count does not match enum variant.", pattern, LogSeverity::Error);
                ret null;
            }

            let tag: LLVMValueRef = LLVMBuildLoad2(this.builder, LLVMInt32TypeInContext(this.context), this.BuildEnumTagPointer(pointer, _type), "tag");
            let mut result: LLVMValueRef = LLVMBuildICmp(this.builder, LLVMIntPredicate::LLVMIntEQ, tag, LLVMConstInt(LLVMInt32TypeInContext(this.context), variant_index as u64, 0i32), "match_tag");
            let mut i: u64 = 0u64;

            while i < arguments.Size() {
                let mut field_index: u64 = i;

                if is_struct_pattern {
                    let index: i64 = this.VariantFieldIndex(_type, variant_index as u64, &struct_field_names[i]);

                    if index == -1i64 {
                        Logger::Log("Unknown field '" + struct_field_names[i] + "' in pattern for variant '" + variant_name + "'.", pattern, LogSeverity::Error);
                        ret null;
                    }

                    field_index = index as u64;
                }

                let field_ptr: LLVMValueRef = this.BuildPayloadFieldPointer(pointer, _type, variant_index as u64, field_index);
                let field_result: LLVMValueRef = this.BuildPatternCondition(arguments[i], field_ptr, variant_types[field_index]);
                result = LLVMBuildAnd(this.builder, result, field_result, "match_pattern");
                i += 1u64;
            } ret result;
        }

        if pattern->node_type == ASTNodeType::IDENTIFIER {
            ret LLVMConstInt(LLVMInt1TypeInContext(this.context), 1u64, 0i32);
        }

        let value: QualifiedValue = QualifiedValue(LLVMBuildLoad2(this.builder, _type->Value(), pointer, "match_value"), _type);

        if pattern->node_type == ASTNodeType::SCOPE_RESOLUTION {
            let constant: QualifiedValue = this.CompileExpression(pattern, false);

            if !constant.Null() {
                ret this.CompileBinaryOperation2(value, constant, TokenType::EQUAL, false, pattern).Value();
            } else {
                ret null;
            }
        }

        if pattern->node_type == ASTNodeType::LITERAL {
            let constant: QualifiedValue = this.CompileExpression(pattern, false);

            if !constant.Null() {
                ret this.CompileBinaryOperation2(value, constant, TokenType::EQUAL, false, pattern).Value();
            } else {
                ret null;
            }
        }

        Logger::Log("Invalid match pattern.", pattern, LogSeverity::Error);
        ret null;
    }

    priv BindPattern(&mut this, pattern: *const ASTNode, pointer: LLVMValueRef, _type: *const QualifiedType) {
        if this.PatternIsWildcard(pattern) {
            ret;
        }

        if pattern->node_type == ASTNodeType::OR_PATTERN {
            this.BindPattern((pattern as *const OrPatternNode)->left, pointer, _type);
            ret;
        }

        if _type->IsEnum() {
            if pattern->node_type == ASTNodeType::CALL {
                let call: *const CallNode = pattern as *const CallNode;
                let mut variant_name: String;

                if call->expression->node_type == ASTNodeType::IDENTIFIER {
                    variant_name = (call->expression as *const IdentifierNode)->name;
                } else {
                    variant_name = (call->expression as *const ScopeResolutionNode)->identifier->name;
                }

                let variant_index: i64 = this.VariantIndex(_type, &variant_name);
                let mut i: u64 = 0u64;

                while i < _type->variants[variant_index as u64].right.Size() {
                    let field_ptr: LLVMValueRef = this.BuildPayloadFieldPointer(pointer, _type, variant_index as u64, i);
                    this.BindPattern(call->arguments[i], field_ptr, _type->variants[variant_index as u64].right[i]);
                    i += 1u64;
                } ret;
            }

            if pattern->node_type == ASTNodeType::STRUCT_INIT {
                let struct_init: *const StructInitNode = pattern as *const StructInitNode;
                let mut variant_name: String;

                if struct_init->expression->node_type == ASTNodeType::IDENTIFIER {
                    variant_name = (struct_init->expression as *const IdentifierNode)->name;
                } else {
                    variant_name = (struct_init->expression as *const ScopeResolutionNode)->identifier->name;
                }

                let variant_index: i64 = this.VariantIndex(_type, &variant_name);
                let mut i: u64 = 0u64;

                while i < struct_init->field_names.Size() {
                    let index: i64 = this.VariantFieldIndex(_type, variant_index as u64, &struct_init->field_names[i]);

                    if index == -1i64 {
                        Logger::Log("Unknown field '" + struct_init->field_names[i] + "' in pattern.", pattern, LogSeverity::Error);
                        ret;
                    }

                    let field_ptr: LLVMValueRef = this.BuildPayloadFieldPointer(pointer, _type, variant_index as u64, index as u64);
                    this.BindPattern(struct_init->field_values[i], field_ptr, _type->variants[variant_index as u64].right[index as u64]);
                    i += 1u64;
                } ret;
            }

            if pattern->node_type == ASTNodeType::IDENTIFIER {
                let identifier: *const IdentifierNode = pattern as *const IdentifierNode;
                if this.VariantIndex(_type, &identifier->name) != -1i64 { ret; }
            } else if pattern->node_type == ASTNodeType::SCOPE_RESOLUTION {
                ret;
            }
        }

        if pattern->node_type == ASTNodeType::IDENTIFIER {
            let value: QualifiedValue = QualifiedValue(pointer, this.type_manager.Pointer(_type, false), false, true);
            this.scope_manager.Set((pattern as *const IdentifierNode)->name, SymbolKind::Variable, value, false, pattern);
        }
    }

    priv CompileMatch(&mut this, match_stmt: *const MatchStmtNode) {
        let mut expression: QualifiedValue = this.CompileExpression(match_stmt->expression, false);
        if expression.Null() { ret; }

        let function: LLVMValueRef = LLVMGetBasicBlockParent(LLVMGetInsertBlock(this.builder));
        let end_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "match_end");
        let mut default_block: LLVMBasicBlockRef = end_block;
        let mut any_arm_branches_to_end: bool = false;

        if match_stmt->default_case != null {
            default_block = LLVMAppendBasicBlockInContext(this.context, function, "match_default");
        }

        let mut match_pointer: LLVMValueRef = null;

        if expression.Type().IsReference() {
            if expression.Type().Pointee().IsEnum() {
                match_pointer = expression.Value();
                expression = QualifiedValue(LLVMBuildLoad2(this.builder, expression.Type().Pointee().Value(), expression.Value(), ""), expression.Type().Pointee());
            } else {
                expression = QualifiedValue(LLVMBuildLoad2(this.builder, expression.Type().Pointee().Value(), expression.Value(), ""), expression.Type().Pointee());
            }
        }

        if match_pointer == null && expression.Type().IsEnum() {
            match_pointer = LLVMBuildAlloca(this.builder, expression.Type().Value(), "match_value");
            LLVMBuildStore(this.builder, expression.Value(), match_pointer);
        }

        let mut current_block: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
        let mut i: u64 = 0u64;

        while i < match_stmt->cases.Size() {
            let case_stmt: *const CaseStmtNode = match_stmt->cases[i];
            let body_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "match_case");
            let mut next_block: LLVMBasicBlockRef = default_block;

            if i + 1u64 < match_stmt->cases.Size() {
                next_block = LLVMAppendBasicBlockInContext(this.context, function, "match_next");
            }

            LLVMPositionBuilderAtEnd(this.builder, current_block);
            let mut condition: LLVMValueRef = null;

            if expression.Type().IsEnum() {
                condition = this.BuildPatternCondition(case_stmt->pattern, match_pointer, &expression.Type());
            } else {
                let value: QualifiedValue = this.CompileExpression(case_stmt->pattern, false);

                if !value.Null() {
                    condition = this.CompileBinaryOperation2(expression, value, TokenType::EQUAL, false, case_stmt->pattern).Value();
                } else {
                    ret;
                }
            }

            if case_stmt->guard != null {
                let guard_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "match_guard");
                let guard_fail: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "match_guard_fail");
                LLVMBuildCondBr(this.builder, condition, guard_block, next_block);

                LLVMPositionBuilderAtEnd(this.builder, guard_block);
                this.scope_manager.PushScope(String("guard"), false);
                if expression.Type().IsEnum() { this.BindPattern(case_stmt->pattern, match_pointer, &expression.Type()); }
                let guard_cond: LLVMValueRef = this.CompileExpression(case_stmt->guard, false).Value();
                if guard_cond == null { ret; }
                LLVMBuildCondBr(this.builder, guard_cond, body_block, guard_fail);

                LLVMPositionBuilderAtEnd(this.builder, guard_fail);
                this.scope_manager.PopScope();
                LLVMBuildBr(this.builder, next_block);

                LLVMPositionBuilderAtEnd(this.builder, body_block);
                this.scope_manager.PushScope(String("case"), false);
                if expression.Type().IsEnum() { this.BindPattern(case_stmt->pattern, match_pointer, &expression.Type()); }
            } else {
                LLVMBuildCondBr(this.builder, condition, body_block, next_block);

                LLVMPositionBuilderAtEnd(this.builder, body_block);
                this.scope_manager.PushScope(String("case"), false);
                if expression.Type().IsEnum() { this.BindPattern(case_stmt->pattern, match_pointer, &expression.Type()); }
            }

            this.CompileStatement(case_stmt->body);
            this.scope_manager.PopScope();

            if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
                if LLVMGetFirstUse(LLVMBasicBlockAsValue(LLVMGetInsertBlock(this.builder))) == null {
                    LLVMBuildUnreachable(this.builder);
                } else {
                    LLVMBuildBr(this.builder, end_block);
                    any_arm_branches_to_end = true;
                }
            }

            current_block = next_block;
            i += 1u64;
        }

        if match_stmt->default_case != null {
            LLVMPositionBuilderAtEnd(this.builder, default_block);
            this.scope_manager.PushScope(String("default"), false);
            this.CompileStatement(match_stmt->default_case->body);
            this.scope_manager.PopScope();

            if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
                if LLVMGetFirstUse(LLVMBasicBlockAsValue(LLVMGetInsertBlock(this.builder))) == null {
                    LLVMBuildUnreachable(this.builder);
                } else {
                    LLVMBuildBr(this.builder, end_block);
                    any_arm_branches_to_end = true;
                }
            }
        } else if current_block != end_block {
            LLVMPositionBuilderAtEnd(this.builder, current_block);

            if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
                LLVMBuildBr(this.builder, end_block);
                any_arm_branches_to_end = true;
            }
        }

        if !any_arm_branches_to_end && LLVMGetBasicBlockTerminator(end_block) == null {
            LLVMPositionBuilderAtEnd(this.builder, end_block);
            LLVMBuildUnreachable(this.builder);
        } else {
            LLVMPositionBuilderAtEnd(this.builder, end_block);
        }
    }

    priv CompileExtern(&mut this, extern_block: *const ExternBlockNode) {
        if !this.mangling {
            Logger::Log("Already in a extern block.", extern_block as *const ASTNode, LogSeverity::Error);
            ret;
        }

        if extern_block->linkage != "C" {
            Logger::Log("Unknown linkage '" + extern_block->linkage + "'.", extern_block as *const ASTNode, LogSeverity::Error);
            ret;
        }

        this.mangling = false;
        let mut i: u64 = 0u64;

        while i < extern_block->declarations.Size() {
            let decl: *const ASTNode = extern_block->declarations[i];
            this.CompileDeclaration(decl);
            i += 1u64;
        }

        this.mangling = true;
    }

    priv CompileBlock(&mut this, block: *const BlockStmtNode) {
        let mut i: u64 = 0u64;

        while i < block->statements.Size() {
            let stmt: *const ASTNode = block->statements[i];
            this.CompileStatement(stmt);
            i += 1u64;
        }
    }

    priv CompileStatement(&mut this, stmt: *const ASTNode) {
        if stmt->node_type == ASTNodeType::RETURN_STMT {
            this.CompileReturn(stmt as *const ReturnStmtNode);
        } else if stmt->node_type == ASTNodeType::EXPRESSION_STMT {
            this.CompileExpression((stmt as *const ExpressionStmtNode)->expression, false);
        } else if stmt->node_type == ASTNodeType::IF_STMT {
            this.CompileIf(stmt as *const IfStmtNode);
        } else if stmt->node_type == ASTNodeType::IF_LET_STMT {
            this.CompileIfLet(stmt as *const IfLetStmtNode);
        } else if stmt->node_type == ASTNodeType::WHILE_STMT {
            this.CompileWhile(stmt as *const WhileStmtNode);
        } else if stmt->node_type == ASTNodeType::WHILE_LET_STMT {
            this.CompileWhileLet(stmt as *const WhileLetStmtNode);
        } else if stmt->node_type == ASTNodeType::FOR_STMT {
            this.CompileFor(stmt as *const ForStmtNode);
        } else if stmt->node_type == ASTNodeType::LOOP_STMT {
            this.CompileLoop(stmt as *const LoopStmtNode);
        } else if stmt->node_type == ASTNodeType::MATCH_STMT {
            this.CompileMatch(stmt as *const MatchStmtNode);
        } else if stmt->node_type == ASTNodeType::BLOCK_STMT {
            this.CompileBlock(stmt as *const BlockStmtNode);
        } else if stmt->node_type == ASTNodeType::CONTINUE_STMT {
            this.CompileContinue(stmt as *const ContinueStmtNode);
        } else if stmt->node_type == ASTNodeType::BREAK_STMT {
            this.CompileBreak(stmt as *const BreakStmtNode);
        } else if stmt->node_type == ASTNodeType::VARIABLE_DECL {
            this.CompileVariable(stmt as *const VariableDeclNode);
        } else if stmt->node_type == ASTNodeType::ASSIGNMENT {
            this.CompileAssignment(stmt as *const AssignmentNode);
        } else if stmt->node_type == ASTNodeType::INLINE_ASM {
            this.CompileInlineAsm(stmt as *const InlineAsmNode);
        } else {
            Logger::Log("Unknown statement '" + stmt->node_type.ToString() + "'.", stmt, LogSeverity::Error);
        }
    }

    priv CompileReturn(&mut this, ret_stmt: *const ReturnStmtNode) {
        if ret_stmt->expression != null {
            let return: &QualifiedType = this.function->Return();
            let params: Vector<*const QualifiedType> = this.function->Parameters();
            let mut state: bool = false;

            if !params.Empty() {
                state = params[0u64]->sret != null;
            }

            if return.sret != null || state {
                let mut value: QualifiedValue = this.CompileExpression(ret_stmt->expression, true);

                if value.Null() {
                    ret;
                }

                if value.Type().Pointee().IsReference() {
                    value = QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
                }

                if LLVMGetTypeKind(return.Value()) == LLVMTypeKind::LLVMIntegerTypeKind {
                    if *return.sret != value.Type().Pointee() {
                        Logger::Log("Incompatible return types. ('" + LLVMTypeToString(return.sret->Value()) + "' != '" + LLVMTypeToString(value.Type().Pointee().Value()) + "').", ret_stmt as *const ASTNode, LogSeverity::Error);
                        ret;
                    }

                    this.scope_manager.InvokeDestructors(value);
                    LLVMBuildRet(this.builder, LLVMBuildLoad2(this.builder, return.Value(), value.Value(), ""));
                } else {
                    if *params[0u64]->sret != value.Type().Pointee() {
                        Logger::Log("Incompatible return types. ('" + LLVMTypeToString(return.sret->Value()) + "' != '" + LLVMTypeToString(value.Type().Pointee().Value()) + "').", ret_stmt as *const ASTNode, LogSeverity::Error);
                        ret;
                    }

                    let mut _params: Vector<QualifiedValue>;
                    _params.PushBack(value);
                    this.CompileConstructor(value.Type().Pointee(), QualifiedValue(LLVMGetParam(this.function_ref, 0u32), params[0u64]), _params, ret_stmt as *const ASTNode);
                    this.scope_manager.InvokeDestructors(value);
                    LLVMBuildRetVoid(this.builder);
                }
            } else {
                let mut value: QualifiedValue = this.CompileExpression(ret_stmt->expression, false);

                if value.Null() {
                    ret;
                }

                if value.Type().IsReference() {
                    if return == value.Type().Pointee() {
                        value = QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
                    }
                }

                if return.IsReference() {
                    if return.Pointee() == value.Type() {
                        value = QualifiedValue(LLVMAddressOf(value.Value(), this.builder), this.type_manager.Pointer(value.Type(), value.Type().IsMutable()));
                    }
                }

                let mut state: bool = false;

                if return.IsPointer() && value.Type().IsPointer() {
                    if LLVMGetTypeKind(return.Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(value.Type().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                        state = true;
                    }
                }

                if return != value.Type() && !state {
                    Logger::Log("Incompatible return types. ('" + LLVMTypeToString(return.Value()) + "' != '" + LLVMTypeToString(value.Type().Value()) + "').", ret_stmt as *const ASTNode, LogSeverity::Error);
                    ret;
                }

                this.scope_manager.InvokeDestructors();
                LLVMBuildRet(this.builder, value.Value());
            }
        } else {
            this.scope_manager.InvokeDestructors();
            LLVMBuildRetVoid(this.builder);
        }
    }

    priv CompileCondition(&mut this, condition: *const ASTNode) -> LLVMValueRef {
        let mut value: QualifiedValue = this.CompileExpression(condition, false);

        if value.Null() {
            ret null;
        }

        if value.Type().IsReference() {
            value = QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
        }

        if LLVMGetTypeKind(value.Type().Value()) != LLVMTypeKind::LLVMIntegerTypeKind || LLVMGetIntTypeWidth(value.Type().Value()) != 1u32 {
            Logger::Log("Invalid condition type '" + LLVMTypeToString(value.Type().Value()) + "'.", condition, LogSeverity::Error);
        }

        ret value.Value();
    }

    priv CompileIf(&mut this, if_stmt: *const IfStmtNode) {
        let function: LLVMValueRef = LLVMGetBasicBlockParent(LLVMGetInsertBlock(this.builder));
        let then_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let (mut else_block: LLVMBasicBlockRef, mut end_block: LLVMBasicBlockRef) = (null, null);

        if if_stmt->else_stmt != null {
            else_block = LLVMAppendBasicBlockInContext(this.context, function, "");
        } else {
            if end_block == null {
                end_block = LLVMAppendBasicBlockInContext(this.context, function, "");
            } else_block = end_block;
        }

        let condition: LLVMValueRef = this.CompileCondition(if_stmt->condition);

        if condition != null {
            LLVMBuildCondBr(this.builder, condition, then_block, else_block);
        } else {
            ret;
        }

        LLVMPositionBuilderAtEnd(this.builder, then_block);
        this.scope_manager.PushScope(String("then"), false);
        this.CompileBlock(if_stmt->then_stmt as *const BlockStmtNode);
        this.scope_manager.PopScope();

        if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
            if end_block == null {
                end_block = LLVMAppendBasicBlockInContext(this.context, function, "");
            } LLVMBuildBr(this.builder, end_block);
        }

        if if_stmt->else_stmt != null {
            LLVMPositionBuilderAtEnd(this.builder, else_block);
            this.scope_manager.PushScope(String("else"), false);

            if if_stmt->else_stmt->node_type == ASTNodeType::IF_LET_STMT {
                this.CompileIfLet(if_stmt->else_stmt as *const IfLetStmtNode);
            } else if if_stmt->else_stmt->node_type == ASTNodeType::IF_STMT {
                this.CompileIf(if_stmt->else_stmt as *const IfStmtNode);
            } else {
                this.CompileBlock(if_stmt->else_stmt as *const BlockStmtNode);
            }

            this.scope_manager.PopScope();

            if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
                if end_block == null {
                    end_block = LLVMAppendBasicBlockInContext(this.context, function, "");
                } LLVMBuildBr(this.builder, end_block);
            }
        }

        if end_block != null {
            LLVMPositionBuilderAtEnd(this.builder, end_block);
        }
    }

    priv CompileIfLet(&mut this, if_let: *const IfLetStmtNode) {
        let function: LLVMValueRef = LLVMGetBasicBlockParent(LLVMGetInsertBlock(this.builder));
        let then_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let (mut else_block: LLVMBasicBlockRef, mut end_block: LLVMBasicBlockRef) = (null, null);

        if if_let->else_stmt != null {
            else_block = LLVMAppendBasicBlockInContext(this.context, function, "");
        } else {
            if end_block == null {
                end_block = LLVMAppendBasicBlockInContext(this.context, function, "");
            } else_block = end_block;
        }

        let mut expression: QualifiedValue = this.CompileExpression(if_let->expression, false);

        if expression.Null() {
            ret;
        }

        if expression.Type().IsReference() {
            expression = QualifiedValue(LLVMBuildLoad2(this.builder, expression.Type().Pointee().Value(), expression.Value(), ""), expression.Type().Pointee());
        }

        let current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
        LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(function));
        let mut match_pointer: LLVMValueRef = LLVMBuildAlloca(this.builder, expression.Type().Value(), "");
        LLVMPositionBuilderAtEnd(this.builder, current);
        LLVMBuildStore(this.builder, expression.Value(), match_pointer);
        let condition: LLVMValueRef = this.BuildPatternCondition(if_let->pattern, match_pointer, &expression.Type());
        LLVMBuildCondBr(this.builder, condition, then_block, else_block);

        LLVMPositionBuilderAtEnd(this.builder, then_block);
        this.scope_manager.PushScope(String("then"), false);
        this.BindPattern(if_let->pattern, match_pointer, &expression.Type());
        this.CompileStatement(if_let->then_stmt);
        this.scope_manager.PopScope();

        if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
            if end_block == null {
                end_block = LLVMAppendBasicBlockInContext(this.context, function, "");
            } LLVMBuildBr(this.builder, end_block);
        }

        if if_let->else_stmt != null {
            LLVMPositionBuilderAtEnd(this.builder, else_block);
            this.scope_manager.PushScope(String("else"), false);

            if if_let->else_stmt->node_type == ASTNodeType::IF_LET_STMT {
                this.CompileIfLet(if_let->else_stmt as *const IfLetStmtNode);
            } else if if_let->else_stmt->node_type == ASTNodeType::IF_STMT {
                this.CompileIf(if_let->else_stmt as *const IfStmtNode);
            } else {
                this.CompileBlock(if_let->else_stmt as *const BlockStmtNode);
            }

            this.scope_manager.PopScope();

            if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
                if end_block == null {
                    end_block = LLVMAppendBasicBlockInContext(this.context, function, "");
                } LLVMBuildBr(this.builder, end_block);
            }
        }

        if end_block != null {
            LLVMPositionBuilderAtEnd(this.builder, end_block);
        }
    }

    priv CompileWhileLet(&mut this, while_let: *const WhileLetStmtNode) {
        let function: LLVMValueRef = LLVMGetBasicBlockParent(LLVMGetInsertBlock(this.builder));
        let compare_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let loop_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let end_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");

        LLVMBuildBr(this.builder, compare_block);
        LLVMPositionBuilderAtEnd(this.builder, compare_block);

        let mut expression: QualifiedValue = this.CompileExpression(while_let->expression, false);

        if expression.Null() {
            ret;
        }

        if expression.Type().IsReference() {
            expression = QualifiedValue(LLVMBuildLoad2(this.builder, expression.Type().Pointee().Value(), expression.Value(), ""), expression.Type().Pointee());
        }

        let current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
        LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(function));
        let mut match_pointer: LLVMValueRef = LLVMBuildAlloca(this.builder, expression.Type().Value(), "");
        LLVMPositionBuilderAtEnd(this.builder, current);
        LLVMBuildStore(this.builder, expression.Value(), match_pointer);
        let condition: LLVMValueRef = this.BuildPatternCondition(while_let->pattern, match_pointer, &expression.Type());
        LLVMBuildCondBr(this.builder, condition, loop_block, end_block);

        LLVMPositionBuilderAtEnd(this.builder, loop_block);
        this.blocks.PushBack(Pair<LLVMBasicBlockRef, LLVMBasicBlockRef>(compare_block, end_block));
        this.scope_manager.PushScope(String("while"), false);
        this.BindPattern(while_let->pattern, match_pointer, &expression.Type());
        this.CompileStatement(while_let->loop_stmt);
        this.scope_manager.PopScope();
        this.blocks.PopBack();

        if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
            LLVMBuildBr(this.builder, compare_block);
        }

        LLVMPositionBuilderAtEnd(this.builder, end_block);
    }

    priv CompileWhile(&mut this, while_stmt: *const WhileStmtNode) {
        let function: LLVMValueRef = LLVMGetBasicBlockParent(LLVMGetInsertBlock(this.builder));
        let compare_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let loop_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let end_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");

        if while_stmt->else_stmt != null {
            let else_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
            let condition: LLVMValueRef = this.CompileCondition(while_stmt->condition);

            if condition != null {
                LLVMBuildCondBr(this.builder, condition, loop_block, else_block);
            } else {
                ret;
            }

            LLVMPositionBuilderAtStart(this.builder, else_block);
            this.scope_manager.PushScope(String("else"), false);
            this.CompileBlock(while_stmt->else_stmt as *const BlockStmtNode);
            this.scope_manager.PopScope();

            if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
                LLVMBuildBr(this.builder, end_block);
            }
        } else {
            LLVMBuildBr(this.builder, compare_block);
        }

        LLVMPositionBuilderAtStart(this.builder, compare_block);
        let condition: LLVMValueRef = this.CompileCondition(while_stmt->condition);

        if condition != null {
            LLVMBuildCondBr(this.builder, condition, loop_block, end_block);
        } else {
            ret;
        }

        LLVMPositionBuilderAtStart(this.builder, loop_block);
        this.blocks.PushBack(Pair<LLVMBasicBlockRef, LLVMBasicBlockRef>(compare_block, end_block));
        this.scope_manager.PushScope(String("while"), false);
        this.CompileBlock(while_stmt->loop_stmt as *const BlockStmtNode);
        this.scope_manager.PopScope();
        this.blocks.PopBack();

        if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
            LLVMBuildBr(this.builder, compare_block);
        }

        LLVMPositionBuilderAtStart(this.builder, end_block);
    }

    priv CompileFor(&mut this, for_stmt: *const ForStmtNode) {
        if for_stmt->iterable->node_type != ASTNodeType::RANGE_EXPR {
            Logger::Log("For loop currently only supports range expressions.", for_stmt as *const ASTNode, LogSeverity::Error);
            ret;
        }

        let range: *const RangeExprNode = for_stmt->iterable as *const RangeExprNode;
        let start_val: QualifiedValue = this.CompileExpression(range->start, false);

        if start_val.Null() {
            ret;
        }

        let end_val: QualifiedValue = this.CompileExpression(range->end, false);

        if end_val.Null() {
            ret;
        }

        let iter_type: *const QualifiedType = &start_val.Type();

        let current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
        LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(LLVMGetBasicBlockParent(current)));
        let iter_alloca: LLVMValueRef = LLVMBuildAlloca(this.builder, iter_type->Value(), "");
        LLVMPositionBuilderAtEnd(this.builder, current);
        LLVMBuildStore(this.builder, start_val.Value(), iter_alloca);

        let function: LLVMValueRef = LLVMGetBasicBlockParent(LLVMGetInsertBlock(this.builder));
        let compare_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let loop_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let step_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let end_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");

        LLVMBuildBr(this.builder, compare_block);
        LLVMPositionBuilderAtStart(this.builder, compare_block);

        let iter_val: LLVMValueRef = LLVMBuildLoad2(this.builder, iter_type->Value(), iter_alloca, "");
        let mut condition: LLVMValueRef = null;
        let type_kind: LLVMTypeKind = LLVMGetTypeKind(iter_type->Value());

        if type_kind == LLVMTypeKind::LLVMFloatTypeKind || type_kind == LLVMTypeKind::LLVMDoubleTypeKind {
            if range->inclusive {
                condition = LLVMBuildFCmp(this.builder, LLVMRealPredicate::LLVMRealOLE, iter_val, end_val.Value(), "");
            } else {
                condition = LLVMBuildFCmp(this.builder, LLVMRealPredicate::LLVMRealOLT, iter_val, end_val.Value(), "");
            }
        } else {
            if range->inclusive {
                condition = LLVMBuildICmp(this.builder, iter_type->IsSigned() ? LLVMIntPredicate::LLVMIntSLE : LLVMIntPredicate::LLVMIntULE, iter_val, end_val.Value(), "");
            } else {
                condition = LLVMBuildICmp(this.builder, iter_type->IsSigned() ? LLVMIntPredicate::LLVMIntSLT : LLVMIntPredicate::LLVMIntULT, iter_val, end_val.Value(), "");
            }
        }

        LLVMBuildCondBr(this.builder, condition, loop_block, end_block);

        LLVMPositionBuilderAtStart(this.builder, loop_block);
        this.blocks.PushBack(Pair<LLVMBasicBlockRef, LLVMBasicBlockRef>(step_block, end_block));
        this.scope_manager.PushScope(String("for"), false);

        let iter_ptr: QualifiedValue = QualifiedValue(iter_alloca, this.type_manager.Pointer(iter_type, false), false, true);
        this.scope_manager.Set(for_stmt->variable, SymbolKind::Variable, iter_ptr, false, for_stmt as *const ASTNode);

        this.CompileBlock(for_stmt->loop_stmt as *const BlockStmtNode);
        this.scope_manager.PopScope();
        this.blocks.PopBack();

        if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
            LLVMBuildBr(this.builder, step_block);
        }

        LLVMPositionBuilderAtStart(this.builder, step_block);
        let current_val: LLVMValueRef = LLVMBuildLoad2(this.builder, iter_type->Value(), iter_alloca, "");
        let mut next_val: LLVMValueRef = null;

        if type_kind == LLVMTypeKind::LLVMFloatTypeKind || type_kind == LLVMTypeKind::LLVMDoubleTypeKind {
            next_val = LLVMBuildFAdd(this.builder, current_val, LLVMConstReal(iter_type->Value(), 1.0f64), "");
        } else {
            next_val = LLVMBuildAdd(this.builder, current_val, LLVMConstInt(iter_type->Value(), 1u64, 0i32), "");
        }

        LLVMBuildStore(this.builder, next_val, iter_alloca);
        LLVMBuildBr(this.builder, compare_block);

        LLVMPositionBuilderAtStart(this.builder, end_block);
    }

    priv CompileLoop(&mut this, loop_stmt: *const LoopStmtNode) {
        let function: LLVMValueRef = LLVMGetBasicBlockParent(LLVMGetInsertBlock(this.builder));
        let loop_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let end_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        this.blocks.PushBack(Pair<LLVMBasicBlockRef, LLVMBasicBlockRef>(loop_block, end_block));

        LLVMBuildBr(this.builder, loop_block);
        LLVMPositionBuilderAtStart(this.builder, loop_block);
        this.scope_manager.PushScope(String("loop"), false);
        this.CompileBlock(loop_stmt->loop_stmt as *const BlockStmtNode);
        this.scope_manager.PopScope();

        if LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(this.builder)) == null {
            LLVMBuildBr(this.builder, loop_block);
        }

        LLVMPositionBuilderAtStart(this.builder, end_block);
        this.blocks.PopBack();
    }

    priv CompileContinue(&this, continue_stmt: *const ContinueStmtNode) {
        if this.blocks.Empty() {
            Logger::Log("Continue statement outside of loop.", continue_stmt as *const ASTNode, LogSeverity::Error);
            ret;
        }

        // this.scope_manager.InvokeDestructors();
        LLVMBuildBr(this.builder, this.blocks[this.blocks.Size() - 1u64].left);
    }

    priv CompileBreak(&this, break_stmt: *const BreakStmtNode) {
        if this.blocks.Empty() {
            Logger::Log("Break statement outside of loop.", break_stmt as *const ASTNode, LogSeverity::Error);
            ret;
        }

        // this.scope_manager.InvokeDestructors();
        LLVMBuildBr(this.builder, this.blocks[this.blocks.Size() - 1u64].right);
    }

    priv CompileVariable(&mut this, variable: *const VariableDeclNode) {
        let mut _type: *const QualifiedType = this.CompileType(variable->_type);

        if _type->IsClass() {
            let mut params: Vector<QualifiedValue>;
            let mut has_error: bool = false;
            let mut skip: bool = false;

            if variable->initializer != null {
                if variable->initializer->node_type != ASTNodeType::INITIALIZER_LIST {
                    let mut value: QualifiedValue = this.CompileExpression(variable->initializer, false);

                    if !value.Null() {
                        if !value.return {
                            if value.Type() == *_type {
                                value = QualifiedValue(LLVMAddressOf(value.Value(), this.builder), this.type_manager.Pointer(value.Type(), true));
                            } params.PushBack(value);
                        } else {
                            if *_type == value.Type() {
                                this.scope_manager.Set(variable->name, SymbolKind::Variable, QualifiedValue(LLVMAddressOf(value.Value(), this.builder), this.type_manager.Pointer(_type, variable->mutable), false, true), false, variable as *const ASTNode);
                                skip = true;
                            } else {
                                Logger::Log("Incompatible variable initialization types. ('" + LLVMTypeToString(_type->Value()) + "' != '" + LLVMTypeToString(value.Type().Value()) + "').", variable as *const ASTNode, LogSeverity::Error);
                                has_error = true;
                            }
                        }
                    } else {
                        has_error = true;
                    }
                } else {
                    let initializer_list: *const InitializerListNode = variable->initializer as *const InitializerListNode;
                    let mut i: u64 = 0u64;

                    while i < initializer_list->expressions.Size() {
                        let value: QualifiedValue = this.CompileExpression(initializer_list->expressions[i], false);

                        if value.Null() {
                            has_error = true;
                            break;
                        }

                        params.PushBack(value);
                        i += 1u64;
                    }
                }
            }

            if !skip {
                if !has_error {
                    let current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
                    LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(LLVMGetBasicBlockParent(current)));
                    let instance: QualifiedValue = QualifiedValue(LLVMBuildAlloca(this.builder, _type->Value(), ""), this.type_manager.Pointer(_type, variable->mutable), false, true);
                    LLVMPositionBuilderAtEnd(this.builder, current);

                    this.CompileConstructor(_type, instance, params, variable as *const ASTNode);
                    this.scope_manager.Set(variable->name, SymbolKind::Variable, instance, false, variable as *const ASTNode);
                    this.scope_manager.RegisterInstance(instance);
                } else {
                    this.scope_manager.Set(variable->name, SymbolKind::Variable, QualifiedValue(null, null), false, variable as *const ASTNode);
                }
            }
        } else {
            if variable->initializer != null {
                if variable->initializer->node_type == ASTNodeType::INITIALIZER_LIST {
                    let list: *const InitializerListNode = variable->initializer as *const InitializerListNode;

                    if variable->_type->node_type == ASTNodeType::ARRAY_TYPE {
                        let array: *const ArrayTypeNode = variable->_type as *const ArrayTypeNode;

                        if array->size == null && !list->expressions.Empty() {
                            _type = this.type_manager.Array(_type->Pointee(), list->expressions.Size(), _type->IsMutable());
                        }
                    }
                }
            }

            let current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
            LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(LLVMGetBasicBlockParent(current)));
            let pointer: QualifiedValue = QualifiedValue(LLVMBuildAlloca(this.builder, _type->Value(), ""), this.type_manager.Pointer(_type, variable->mutable), false, true);
            LLVMPositionBuilderAtEnd(this.builder, current);

            if variable->initializer != null {
                if variable->initializer->node_type != ASTNodeType::INITIALIZER_LIST {
                    let mut initializer: QualifiedValue = this.CompileExpression(variable->initializer, false);

                    if !initializer.Null() {
                        if initializer.Type().IsReference() {
                            if *_type == initializer.Type().Pointee() {
                                initializer = QualifiedValue(LLVMBuildLoad2(this.builder, initializer.Type().Pointee().Value(), initializer.Value(), ""), initializer.Type().Pointee());
                            }
                        }

                        if _type->IsReference() {
                            if _type->Pointee() == initializer.Type() {
                                initializer = QualifiedValue(LLVMAddressOf(initializer.Value(), this.builder), this.type_manager.Pointer(initializer.Type(), initializer.Type().IsMutable()));
                            }
                        }

                        let mut state: bool = false;

                        if _type->IsPointer() && initializer.Type().IsPointer() {
                            if LLVMGetTypeKind(_type->Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(initializer.Type().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                                state = true;
                            }
                        }

                        if *_type == initializer.Type() || state {
                            LLVMBuildStore(this.builder, initializer.Value(), pointer.Value());
                        } else {
                            Logger::Log("Incompatible variable initialization types. ('" + LLVMTypeToString(_type->Value()) + "' != '" + LLVMTypeToString(initializer.Type().Value()) + "').", variable as *const ASTNode, LogSeverity::Error);
                        }
                    }
                } else {
                    let initializer_list: *const InitializerListNode = variable->initializer as *const InitializerListNode;
                    let mut i: u64 = 0u64;

                    while i < initializer_list->expressions.Size() {
                        let value: QualifiedValue = this.CompileExpression(initializer_list->expressions[i], false);

                        if value.Null() {
                            break;
                        }

                        let indices[]: LLVMValueRef = { LLVMConstInt(LLVMInt32TypeInContext(this.context), i, 0i32) };
                        LLVMBuildStore(this.builder, value.Value(), LLVMBuildGEP2(this.builder, _type->Element().Value(), pointer.Value(), indices, 1u32, ""));
                        i += 1u64;
                    }
                }
            }

            this.scope_manager.Set(variable->name, SymbolKind::Variable, pointer, false, variable as *const ASTNode);
        }

        if variable->next != null {
            this.CompileVariable(variable->next);
        }
    }

    priv CompileAssignment(&mut this, assignment: *const AssignmentNode) -> QualifiedValue {
        let pointer: QualifiedValue = this.CompileExpression(assignment->left, true);

        if pointer.Null() {
            ret QualifiedValue(null, null);
        }

        let mut value: QualifiedValue = this.CompileExpression(assignment->right, false);

        if value.Null() {
            ret QualifiedValue(null, null);
        }

        value = this.CompileAssignment2(value, pointer, assignment->operator, false, assignment as *const ASTNode);

        if assignment->next != null {
            this.CompileAssignment(assignment->next);
            ret QualifiedValue(null, null);
        } else {
            ret value;
        }
    }

    priv CompileAssignment2(&mut this, mut value: QualifiedValue, mut pointer: QualifiedValue, operator: TokenType, ignore: bool, node: *const ASTNode) -> QualifiedValue {
        if pointer.Type().Pointee().IsReference() {
            pointer = QualifiedValue(LLVMBuildLoad2(this.builder, pointer.Type().Pointee().Value(), pointer.Value(), ""), pointer.Type().Pointee());
        }

        if pointer.Type().Pointee().IsClass() {
            let mut params: Vector<QualifiedValue>;
            params.PushBack(value);

            let mut method_name: String = "op";
            method_name += operator.ToAssignmentOperatorString();
            let param_types: Vector<*const QualifiedType> = this.ValueToType(params);
            let _class: &QualifiedType = pointer.Type().Pointee();

            if _class.Has(method_name, param_types, this._class) {
                let method: &Pair<Method, *const QualifiedType> = _class.Get(method_name, param_types, this._class, node);
                ret this.CompileCall2(QualifiedValue(method.left.value, method.right, pointer), params, false, false, node);
            }

            if !pointer.Type().IsMutable() && !ignore {
                Logger::Log("Cannot assign to immutable variable.", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            if value.Type().IsReference() {
                if value.Type().Pointee() == _class {
                    value = QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
                }
            }

            if value.Type() == _class {
                if operator != TokenType::ASSIGN {
                    Logger::Log("Invalid class assignment operation '" + operator.ToString() + "' for type '" + LLVMTypeToString(_class.Value()) + "'.", node, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                }

                let fields: &mut Map<String, Pair<Field, *const QualifiedType>> = _class.Fields();
                value = QualifiedValue(LLVMAddressOf(value.Value(), this.builder), this.type_manager.Pointer(value.Type(), true));
                let mut i: u64 = 0u64;

                while i < fields.Size() {
                    let field: &mut Pair<String, Pair<Field, *const QualifiedType>> = fields[i];
                    let mut _type: *const QualifiedType = field.right.right;

                    if _type->IsPointer() {
                        _type = this.type_manager.Copy(_type, true);
                    }

                    let _value: QualifiedValue = QualifiedValue(LLVMBuildLoad2(this.builder, _type->Value(), LLVMBuildStructGEP2(this.builder, value.Type().Pointee().Value(), value.Value(), _class.Index(field.left) as u32, ""), ""), _type);
                    let _pointer: QualifiedValue = QualifiedValue(LLVMBuildStructGEP2(this.builder, pointer.Type().Pointee().Value(), pointer.Value(), _class.Index(field.left) as u32, ""), this.type_manager.Pointer(_type, true));
                    this.CompileAssignment2(_value, _pointer, operator, ignore, node);
                    i += 1u64;
                }
            } else {
                Logger::Log("Incompatible class assignment types. ('" + LLVMTypeToString(_class.Value()) + "' != '" + LLVMTypeToString(value.Type().Value()) + "').", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }
        } else {
            if operator != TokenType::ASSIGN {
                let other: QualifiedValue = QualifiedValue(LLVMBuildLoad2(this.builder, pointer.Type().Pointee().Value(), pointer.Value(), ""), pointer.Type().Pointee());
                let (value_kind: LLVMTypeKind, other_kind: LLVMTypeKind) = (LLVMGetTypeKind(pointer.Type().Pointee().Value()), LLVMGetTypeKind(value.Type().Value()));

                if value.Type().IsPointer() && other.Type().IsPointer() {
                    if operator == TokenType::MINUS_ASSIGN {
                        let _type: &QualifiedType = this.type_manager.Primitive(LLVMInt64TypeInContext(this.context), false);
                        value = QualifiedValue(LLVMBuildSub(this.builder, LLVMBuildPtrToInt(this.builder, other.Value(), _type.Value(), ""), LLVMBuildPtrToInt(this.builder, value.Value(), _type.Value(), ""), ""), _type);
                    } else {
                        Logger::Log("Invalid pointer assignment operation '" + operator.ToString() + "' for type '" + LLVMTypeToString(value.Type().Value()) + "'.", node, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }
                } else if (value.Type().IsPointer() && other_kind == LLVMTypeKind::LLVMIntegerTypeKind) || (value_kind == LLVMTypeKind::LLVMIntegerTypeKind && other.Type().IsPointer()) {
                    let ptr: &QualifiedValue = value.Type().IsPointer() ? &value : &other;
                    let index: &QualifiedValue = value.Type().IsPointer() ? &other : &value;
                    let width: u32 = LLVMGetIntTypeWidth(index.Type().Value());

                    if width == 64u32 {
                        if operator == TokenType::PLUS_ASSIGN {
                            let indices[]: LLVMValueRef = { index.Value() };
                            value = QualifiedValue(LLVMBuildGEP2(this.builder, ptr.Type().Pointee().Value(), ptr.Value(), indices, 1u32, ""), ptr.Type());
                        } else if operator == TokenType::MINUS_ASSIGN {
                            let indices[]: LLVMValueRef = { LLVMBuildNeg(this.builder, index.Value(), "") };
                            value = QualifiedValue(LLVMBuildGEP2(this.builder, ptr.Type().Pointee().Value(), ptr.Value(), indices, 1u32, ""), ptr.Type());
                        } else {
                            Logger::Log("Invalid pointer assignment operation '" + operator.ToString() + "' for type '" + LLVMTypeToString(ptr.Type().Value()) + "'.", node, LogSeverity::Error);
                            ret QualifiedValue(null, null);
                        }
                    } else {
                        Logger::Log("Invalid index type '" + LLVMTypeToString(index.Type().Value()) + "'.", node, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }
                } else if value_kind == LLVMTypeKind::LLVMIntegerTypeKind && other_kind == LLVMTypeKind::LLVMIntegerTypeKind {
                    if value.Type() != other.Type() {
                        Logger::Log("Incompatible assignment operation types. ('" + LLVMTypeToString(value.Type().Value()) + "' != '" + LLVMTypeToString(other.Type().Value()) + "').", node, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }

                    if operator == TokenType::PLUS_ASSIGN {
                        value = QualifiedValue(LLVMBuildAdd(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else if operator == TokenType::MINUS_ASSIGN {
                        value = QualifiedValue(LLVMBuildSub(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else if operator == TokenType::MUL_ASSIGN {
                        value = QualifiedValue(LLVMBuildMul(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else if operator == TokenType::DIV_ASSIGN {
                        if value.Type().IsSigned() {
                            value = QualifiedValue(LLVMBuildSDiv(this.builder, other.Value(), value.Value(), ""), value.Type());
                        } else {
                            value = QualifiedValue(LLVMBuildUDiv(this.builder, other.Value(), value.Value(), ""), value.Type());
                        }
                    } else if operator == TokenType::MOD_ASSIGN {
                        if value.Type().IsSigned() {
                            value = QualifiedValue(LLVMBuildSRem(this.builder, other.Value(), value.Value(), ""), value.Type());
                        } else {
                            value = QualifiedValue(LLVMBuildURem(this.builder, other.Value(), value.Value(), ""), value.Type());
                        }
                    } else if operator == TokenType::AND_ASSIGN {
                        value = QualifiedValue(LLVMBuildAnd(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else if operator == TokenType::OR_ASSIGN {
                        value = QualifiedValue(LLVMBuildOr(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else if operator == TokenType::XOR_ASSIGN {
                        value = QualifiedValue(LLVMBuildXor(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else if operator == TokenType::LSHIFT_ASSIGN {
                        value = QualifiedValue(LLVMBuildShl(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else if operator == TokenType::RSHIFT_ASSIGN {
                        if value.Type().IsSigned() {
                            value = QualifiedValue(LLVMBuildAShr(this.builder, other.Value(), value.Value(), ""), value.Type());
                        } else {
                            value = QualifiedValue(LLVMBuildLShr(this.builder, other.Value(), value.Value(), ""), value.Type());
                        }
                    } else {
                        Logger::Log("Invalid assignment operation '" + operator.ToString() + "' for type '" + LLVMTypeToString(value.Type().Value()) + "'.", node, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }
                } else if (value_kind == LLVMTypeKind::LLVMFloatTypeKind || value_kind == LLVMTypeKind::LLVMDoubleTypeKind) && (other_kind == LLVMTypeKind::LLVMFloatTypeKind || other_kind == LLVMTypeKind::LLVMDoubleTypeKind) {
                    if value.Type() != other.Type() {
                        Logger::Log("Incompatible assignment operation types. ('" + LLVMTypeToString(value.Type().Value()) + "' != '" + LLVMTypeToString(other.Type().Value()) + "').", node, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }

                    if operator == TokenType::PLUS_ASSIGN {
                        value = QualifiedValue(LLVMBuildFAdd(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else if operator == TokenType::MINUS_ASSIGN {
                        value = QualifiedValue(LLVMBuildFSub(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else if operator == TokenType::MUL_ASSIGN {
                        value = QualifiedValue(LLVMBuildFMul(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else if operator == TokenType::DIV_ASSIGN {
                        value = QualifiedValue(LLVMBuildFDiv(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else if operator == TokenType::MOD_ASSIGN {
                        value = QualifiedValue(LLVMBuildFRem(this.builder, other.Value(), value.Value(), ""), value.Type());
                    } else {
                        Logger::Log("Invalid assignment operation '" + operator.ToString() + "' for type '" + LLVMTypeToString(value.Type().Value()) + "'.", node, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }
                } else {
                    Logger::Log("Invalid type '" + LLVMTypeToString(value.Type().Value()) + "' for assignment operation '" + operator.ToString() + "'.", node, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                }
            }

            if !pointer.Type().IsMutable() && !ignore {
                Logger::Log("Cannot assign to immutable variable.", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            if value.Type().IsReference() {
                if pointer.Type().Pointee() == value.Type().Pointee() {
                    value = QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
                }
            }

            let mut state: bool = false;

            if pointer.Type().Pointee().IsPointer() && value.Type().IsPointer() {
                if LLVMGetTypeKind(pointer.Type().Pointee().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(value.Type().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                    state = true;
                }
            }

            if value.Type() != pointer.Type().Pointee() && !state {
                Logger::Log("Incompatible assignment types. ('" + LLVMTypeToString(pointer.Type().Pointee().Value()) + "' != '" + LLVMTypeToString(value.Type().Value()) + "').", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            LLVMBuildStore(this.builder, value.Value(), pointer.Value());
        } ret pointer;
    }

    priv CompileExpression(&mut this, expression: *const ASTNode, pointer: bool) -> QualifiedValue {
        if expression->node_type == ASTNodeType::LITERAL {
            ret this.CompileLiteral(expression as *const LiteralNode);
        } else if expression->node_type == ASTNodeType::CALL {
            ret this.CompileCall(expression as *const CallNode, pointer);
        } else if expression->node_type == ASTNodeType::TERNARY {
            ret this.CompileTernary(expression as *const TernaryNode, pointer);
        } else if expression->node_type == ASTNodeType::IDENTIFIER || expression->node_type == ASTNodeType::SCOPE_RESOLUTION {
            let symbol: *const Symbol = this.scope_manager.Resolve(expression, false);

            if symbol == null {
                ret QualifiedValue(null, null);
            }

            if symbol->value.Null() {
                ret QualifiedValue(null, null);
            }

            if (symbol->kind == SymbolKind::Variable || symbol->kind == SymbolKind::GlobalVariable || symbol->kind == SymbolKind::Constant || symbol->kind == SymbolKind::Parameter) && !pointer {
                if symbol->value.Type().IsPointer() {
                    if symbol->value.Type().Pointee().IsArray() {
                        let _type: &QualifiedType = this.type_manager.Pointer(symbol->value.Type().Pointee().Element(), symbol->value.Type().IsMutable());
                        ret QualifiedValue(LLVMBuildBitCast(this.builder, symbol->value.Value(), _type.Value(), ""), _type);
                    }
                }

                if symbol->kind == SymbolKind::Constant {
                    ret symbol->value;
                } else if symbol->kind == SymbolKind::GlobalVariable && !symbol->value.Type().Pointee().IsClass() && !symbol->value.Type().Pointee().IsPointer() {
                    ret QualifiedValue(LLVMGetInitializer(symbol->value.Value()), symbol->value.Type().Pointee());
                } else {
                    ret QualifiedValue(LLVMBuildLoad2(this.builder, symbol->value.Type().Pointee().Value(), symbol->value.Value(), ""), symbol->value.Type().Pointee());
                }
            } else if symbol->kind == SymbolKind::Function || pointer {
                ret symbol->value;
            } else {
                Logger::Log("Invalid symbol kind '" + symbol->kind.ToString() + "'.", expression, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }
        } else if expression->node_type == ASTNodeType::NEW {
            ret this.CompileNew(expression as *const NewNode);
        } else if expression->node_type == ASTNodeType::DELETE {
            ret this.CompileDelete(expression as *const DeleteNode);
        } else if expression->node_type == ASTNodeType::CAST {
            let value: QualifiedValue = this.CompileCast(expression as *const CastNode, pointer);

            if !pointer || (pointer && value.Type().IsPointer()) {
                ret value;
            } else {
                Logger::Log("Invalid pointer cast expression.", expression, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }
        } else if expression->node_type == ASTNodeType::INDEX_ACCESS {
            ret this.CompileIndexAccess(expression as *const IndexAccessNode, pointer);
        } else if expression->node_type == ASTNodeType::MEMBER_ACCESS {
            ret this.CompileMemberAccess(expression as *const MemberAccessNode, pointer);
        } else if expression->node_type == ASTNodeType::UNARY_OP {
            ret this.CompileUnaryOperation(expression as *const UnaryOpNode, pointer);
        } else if expression->node_type == ASTNodeType::BINARY_OP {
            ret this.CompileBinaryOperation(expression as *const BinaryOpNode, pointer);
        } else if expression->node_type == ASTNodeType::STRUCT_INIT {
            ret this.CompileStructInit(expression as *const StructInitNode);
        } else {
            Logger::Log("Unknown expression '" + expression->node_type.ToString() + "'.", expression, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }
    }

    priv CompileStructInit(&mut this, node: *const StructInitNode) -> QualifiedValue {
        let mut variant_name: String;

        if node->expression->node_type == ASTNodeType::IDENTIFIER {
            variant_name = (node->expression as *const IdentifierNode)->name;
        } else if node->expression->node_type == ASTNodeType::SCOPE_RESOLUTION {
            variant_name = (node->expression as *const ScopeResolutionNode)->identifier->name;
        } else {
            Logger::Log("Invalid struct init expression.", node as *const ASTNode, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }

        let variant_symbol: *const Symbol = this.scope_manager.Resolve(node->expression, false);

        if variant_symbol == null {
            Logger::Log("Unknown variant '" + variant_name + "'.", node as *const ASTNode, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }

        let mut enum_type: *const QualifiedType = null;

        if variant_symbol->value.Type().IsPointer() {
            enum_type = variant_symbol->value.Type().Pointee().Return();
        } else {
            enum_type = variant_symbol->value.Type().Pointee();
        }

        let variant_index: i64 = this.VariantIndex(enum_type, &variant_name);

        if variant_index == -1i64 {
            Logger::Log("Unknown enum variant '" + variant_name + "'.", node as *const ASTNode, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }

        let variant_types: Vector<*const QualifiedType> = enum_type->variants[variant_index as u64].right;

        if node->field_names.Size() != variant_types.Size() {
            Logger::Log("Struct init field count does not match enum variant.", node as *const ASTNode, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }

        let mut ordered_args: Vector<QualifiedValue>;
        let mut i: u64 = 0u64;

        while i < variant_types.Size() {
            ordered_args.PushBack(QualifiedValue(null, null));
            i += 1u64;
        }

        let mut j: u64 = 0u64;

        while j < node->field_names.Size() {
            let field_index: i64 = this.VariantFieldIndex(enum_type, variant_index as u64, &node->field_names[j]);

            if field_index == -1i64 {
                Logger::Log("Unknown field '" + node->field_names[j] + "' for variant '" + variant_name + "'.", node as *const ASTNode, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            let value: QualifiedValue = this.CompileExpression(node->field_values[j], false);

            if !value.Null() {
                ordered_args[field_index as u64] = value;
            } else {
                ret QualifiedValue(null, null);
            } j += 1u64;
        }

        let tag_type: LLVMTypeRef = LLVMInt32TypeInContext(this.context);
        let struct_type: LLVMTypeRef = enum_type->Value();
        let data_type: LLVMTypeRef = LLVMStructGetTypeAtIndex(struct_type, 1u32);
        let mut alloca: LLVMValueRef = LLVMBuildAlloca(this.builder, struct_type, "struct_init");
        let tag_ptr: LLVMValueRef = LLVMBuildStructGEP2(this.builder, struct_type, alloca, 0u32, "tag_ptr");
        LLVMBuildStore(this.builder, LLVMConstInt(tag_type, variant_index as u64, 0i32), tag_ptr);

        let data_ptr: LLVMValueRef = LLVMBuildStructGEP2(this.builder, struct_type, alloca, 1u32, "data_ptr");
        let payload_type: LLVMTypeRef = this.CreateVariantPayloadType(variant_types);
        let payload_ptr: LLVMValueRef = LLVMBuildBitCast(this.builder, data_ptr, LLVMPointerType(payload_type, 0u32), "payload_ptr");
        let mut k: u64 = 0u64;

        while k < variant_types.Size() {
            let elem_ptr: LLVMValueRef = LLVMBuildStructGEP2(this.builder, payload_type, payload_ptr, k as u32, "");
            LLVMBuildStore(this.builder, ordered_args[k].Value(), elem_ptr);
            k += 1u64;
        }

        ret QualifiedValue(LLVMBuildLoad2(this.builder, struct_type, alloca, ""), enum_type);
    }

    priv CompileLiteral(&mut this, literal: *const LiteralNode) -> QualifiedValue {
        if literal->literal_type == TokenType::INTEGER {
            let (mut state: bool, mut base: i32) = (false, 10i32);
            let (mut signed: bool, mut width: u64) = (true, 32u64);
            let (mut value: String, mut size: String);
            let mut i: u64 = 0u64;

            while i < literal->value.Size() {
                if !state {
                    if i == 0u64 && literal->value[i] == '0' && (literal->value[i + 1u64] == 'x' || literal->value[i + 1u64] == 'o' || literal->value[i + 1u64] == 'b') {
                        if base != 10i32 {
                            Logger::Log("Invalid integer literal '" + literal->value + "'.", literal as *const ASTNode, LogSeverity::Error);
                            ret QualifiedValue(null, null);
                        } else {
                            base = literal->value[i + 1u64] == 'x' ? 16i32 : (literal->value[i + 1u64] == 'o' ? 8i32 : 2i32);
                        } i += 1u64;
                    } else if literal->value[i] == 'u' {
                        (signed, state) = (false, true);
                    } else if literal->value[i] == 'i' {
                        (signed, state) = (true, true);
                    } else {
                        value += literal->value[i];
                    }
                } else {
                    size += literal->value[i];
                } i += 1u64;
            }

            let mut _type: LLVMTypeRef;
            width = size.ToInteger() as u64;

            if width == 128u64 {
                _type = LLVMInt128TypeInContext(this.context);
            } else if width == 64u64 {
                _type = LLVMInt64TypeInContext(this.context);
            } else if width == 32u64 {
                _type = LLVMInt32TypeInContext(this.context);
            } else if width == 16u64 {
                _type = LLVMInt16TypeInContext(this.context);
            } else if width == 8u64 {
                _type = LLVMInt8TypeInContext(this.context);
            } else {
                Logger::Log("Invalid integer size '" + size +  "'.", literal as *const ASTNode, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            ret QualifiedValue(LLVMConstInt(_type, value.ToInteger(base) as u64, signed ? 1i32 : 0i32), this.type_manager.Primitive(_type, signed));
        } else if literal->literal_type == TokenType::FLOAT {
            let (mut state: bool, mut i: u64) = (false, 0u64);
            let (mut value: String, mut size: String);
            let mut width: u64 = 32u64;

            while i < literal->value.Size() {
                if !state {
                    if literal->value[i] == 'f' {
                        state = true;
                    } else {
                        value += literal->value[i];
                    }
                } else {
                    size += literal->value[i];
                } i += 1u64;
            }

            let mut _type: LLVMTypeRef;
            width = size.ToInteger() as u64;

            if width == 64u64 {
                _type = LLVMDoubleTypeInContext(this.context);
            } else if width == 32u64 {
                _type = LLVMFloatTypeInContext(this.context);
            } else {
                Logger::Log("Invalid float size '" + size +  "'.", literal as *const ASTNode, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            ret QualifiedValue(LLVMConstReal(_type, value.ToFloat()), this.type_manager.Primitive(_type, false));
        } else if literal->literal_type == TokenType::TRUE || literal->literal_type == TokenType::FALSE {
            let _type: &QualifiedType = this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false);
            ret QualifiedValue(LLVMConstInt(_type.Value(), literal->literal_type == TokenType::TRUE ? 1u64 : 0u64, 0i32), _type);
        } else if literal->literal_type == TokenType::STRING {
            let value: LLVMValueRef = LLVMBuildGlobalStringPtr(this.builder, literal->value.Data(), "");
            ret QualifiedValue(value, this.type_manager.Pointer(this.type_manager.Primitive(LLVMInt8TypeInContext(this.context), true), false));
        } else if literal->literal_type == TokenType::CHAR {
            if (literal->value.Size() == 2u64 && literal->value[1u64] == '\0') || (literal->value.Size() == 1u64 && literal->value[0u64] == '\0') {
                let character: i8 = literal->value[0u64];
                let _type: &QualifiedType = this.type_manager.Primitive(LLVMInt8TypeInContext(this.context), true);
                ret QualifiedValue(LLVMConstInt(_type.Value(), character as u64, 0i32), _type);
            } else {
                Logger::Log("Invalid character literal '" + literal->value + "'.", literal as *const ASTNode, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }
        } else if literal->literal_type == TokenType::NULL {
            let _type: &QualifiedType = this.type_manager.NullPointer(LLVMVoidTypeInContext(this.context));
            ret QualifiedValue(LLVMConstNull(_type.Value()), _type);
        } else {
            Logger::Log("Unknown literal type '" + literal->literal_type.ToString() + "'.", literal as *const ASTNode, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }
    }

    priv CompileCall(&mut this, call: *const CallNode, pointer: bool) -> QualifiedValue {
        if call->expression->node_type == ASTNodeType::IDENTIFIER {
            let identifier: *const IdentifierNode = call->expression as *const IdentifierNode;

            if identifier->name == "sizeof" {
                if call->arguments.Size() != 1u64 {
                    Logger::Log("Invalid number of arguments for 'sizeof'.", call as *const ASTNode, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                }

                let mut _type: *const QualifiedType;
                let arg: *const ASTNode = call->arguments[0u64];

                if arg->node_type == ASTNodeType::IDENTIFIER || arg->node_type == ASTNodeType::SCOPE_RESOLUTION {
                    let symbol: *const Symbol = this.scope_manager.Resolve(arg, false);

                    if symbol->kind == SymbolKind::Variable || symbol->kind == SymbolKind::GlobalVariable || symbol->kind == SymbolKind::Constant || symbol->kind == SymbolKind::Parameter {
                        if symbol->kind == SymbolKind::Constant {
                            _type = symbol->value.Type();
                        } else {
                            _type = symbol->value.Type().Pointee();
                        }
                    } else if symbol->kind == SymbolKind::Function {
                        _type = symbol->value.Type();
                    } else {
                        Logger::Log("Invalid symbol kind '" + symbol->kind.ToString() + "'.", arg, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }
                } else {
                    _type = this.CompileType(arg);
                }

                let size: u64 = LLVMStoreSizeOfType(this.layout, _type->Value());
                let size_type: &QualifiedType = this.type_manager.Primitive(LLVMInt64TypeInContext(this.context), false);
                ret QualifiedValue(LLVMConstInt(size_type.Value(), size, 0i32), size_type);
            }
        }

        let mut values: Vector<QualifiedValue>;
        let mut i: u64 = 0u64;

        while i < call->arguments.Size() {
            let value: QualifiedValue = this.CompileExpression(call->arguments[i], false);

            if !value.Null() {
                values.PushBack(value);
            } else {
                ret QualifiedValue(null, null);
            } i += 1u64;
        }

        if call->expression->node_type == ASTNodeType::MEMBER_ACCESS {
            let member_access: *const MemberAccessNode = call->expression as *const MemberAccessNode;
            let mut instance: QualifiedValue = this.CompileExpression(member_access->expression, true);

            if instance.Null() {
                ret QualifiedValue(null, null);
            }

            let mut state: bool = false;

            if instance.Type().IsPointer() {
                if instance.Type().Pointee().IsReference() {
                    instance = QualifiedValue(LLVMBuildLoad2(this.builder, instance.Type().Pointee().Value(), instance.Value(), ""), instance.Type().Pointee(), false, instance.binding);
                }

                if instance.binding || instance.Type().IsReference() {
                    if member_access->arrow {
                        instance = QualifiedValue(LLVMBuildLoad2(this.builder, instance.Type().Pointee().Value(), instance.Value(), ""), instance.Type().Pointee(), false, instance.binding);
                    }
                } else {
                    if !member_access->arrow && !instance.return && instance.Type().IsPointer() && (instance.Type().Pointee().IsClass() || instance.Type().Pointee().IsEnum()) {
                        Logger::Log("Expected an arrow operator.", call as *const ASTNode, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }
                }

                if !instance.Type().IsPointer() {
                    state = true;
                } else {
                    if !instance.Type().Pointee().IsClass() && !instance.Type().Pointee().IsEnum() {
                        state = true;
                    }
                }
            } else {
                state = true;
            }

            if state {
                if member_access->arrow {
                    Logger::Log("Expected a dot operator.", call as *const ASTNode, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                }

                if instance.Type().IsPointer() && instance.binding {
                    instance = QualifiedValue(LLVMBuildLoad2(this.builder, instance.Type().Pointee().Value(), instance.Value(), ""), instance.Type().Pointee());
                }

                values.Insert(0u64, instance);
                let symbol: *const Symbol = this.scope_manager.Resolve(member_access->member, this.ValueToType(values), call as *const ASTNode, false);

                if symbol != null {
                    ret this.CompileCall2(symbol->value, values, pointer, false, call as *const ASTNode);
                } else {
                    ret QualifiedValue(null, null);
                }
            } else {
                let mut _state: bool = true;
                let index: i64 = instance.Type().Pointee().IsClass() ? instance.Type().Pointee().Index(member_access->member) : -1i64;
                if this._class != null { _state = (*this._class) != instance.Type().Pointee(); }

                if index != -1i64 {
                    let field: &Pair<Field, *const QualifiedType> = instance.Type().Pointee().Fields()[member_access->member];

                    if field.left.visibility != TokenType::PUBLIC && _state {
                        Logger::Log("Field '" + member_access->member + "' is private.", call as *const ASTNode, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }

                    let field_pointer: LLVMValueRef = LLVMBuildStructGEP2(this.builder, instance.Type().Pointee().Value(), instance.Value(), index as u32, "");
                    ret this.CompileCall2(QualifiedValue(LLVMBuildLoad2(this.builder, field.right->Value(), field_pointer, ""), field.right), values, pointer, false, call as *const ASTNode);
                } else {
                    let method: &Pair<Method, *const QualifiedType> = instance.Type().Pointee().Get(member_access->member, this.ValueToType(values), this._class, call as *const ASTNode);
                    ret this.CompileCall2(QualifiedValue(method.left.value, method.right, instance), values, pointer, false, call as *const ASTNode);
                }
            }
        } else if call->expression->node_type == ASTNodeType::PRIMITIVE_TYPE {
            let _class: &QualifiedType = this.CompileType(call->expression);
            let current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
            LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(LLVMGetBasicBlockParent(current)));
            let instance: QualifiedValue = QualifiedValue(LLVMBuildAlloca(this.builder, _class.Value(), ""), this.type_manager.Pointer(_class, _class.IsMutable()), false, true);
            LLVMPositionBuilderAtEnd(this.builder, current);
            this.CompileConstructor(_class, instance, values, call as *const ASTNode);
            this.scope_manager.RegisterInstance(instance);

            if !pointer {
                ret QualifiedValue(LLVMBuildLoad2(this.builder, _class.Value(), instance.Value(), ""), _class);
            } else {
                ret instance;
            }
        } else {
            let mut state: bool = false;

            if call->expression->node_type == ASTNodeType::IDENTIFIER {
                let identifier: *const IdentifierNode = call->expression as *const IdentifierNode;
                state = !this.scope_manager.Has(identifier->name, SymbolKind::Variable) && !this.scope_manager.Has(identifier->name, SymbolKind::Parameter);
            } else if call->expression->node_type == ASTNodeType::SCOPE_RESOLUTION {
                let resolution: *const ScopeResolutionNode = call->expression as *const ScopeResolutionNode;
                let scope: *const Scope = this.scope_manager.ResolveScopeHalf(resolution, false);

                if scope != null {
                    state = !scope->Has(resolution->identifier->name, SymbolKind::Variable);
                } else {
                    ret QualifiedValue(null, null);
                }
            }

            if state {
                let symbol: *const Symbol = this.scope_manager.Resolve(call->expression, this.ValueToType(values), false);

                if symbol != null {
                    ret this.CompileCall2(symbol->value, values, pointer, false, call as *const ASTNode);
                } else {
                    ret QualifiedValue(null, null);
                }
            } else {
                let value: QualifiedValue = this.CompileExpression(call->expression, false);

                if !value.Null() {
                    ret this.CompileCall2(value, values, pointer, false, call as *const ASTNode);
                } else {
                    ret QualifiedValue(null, null);
                }
            }
        }
    }

    priv CompileCall2(&mut this, mut _func: QualifiedValue, values: &Vector<QualifiedValue>, pointer: bool, ignore: bool, node: *const ASTNode) -> QualifiedValue {
        if _func.Type().Pointee().IsPointer() {
            if _func.Type().Pointee().Pointee().IsFunction() {
                _func = QualifiedValue(LLVMBuildLoad2(this.builder, _func.Type().Pointee().Value(), _func.Value(), ""), _func.Type().Pointee());
            }
        }

        let mut args: Vector<LLVMValueRef>;
        let ret_type: &QualifiedType = _func.Type().Pointee().Return();
        let params: Vector<*const QualifiedType> = _func.Type().Pointee().Parameters();
        let mut return: QualifiedValue = QualifiedValue(null, null);
        let mut i: u64 = 0u64;

        if !params.Empty() {
            if params[0u64]->sret != null {
                let current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
                LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(LLVMGetBasicBlockParent(current)));
                let _pointer: LLVMValueRef = LLVMBuildAlloca(this.builder, params[0u64]->sret->Value(), "");
                return = QualifiedValue(_pointer, this.type_manager.Pointer(params[0u64]->sret, true), true, true);
                LLVMPositionBuilderAtEnd(this.builder, current);
                args.PushBack(return.Value());

                if params[0u64]->sret->IsClass() {
                    this.scope_manager.RegisterInstance(return);
                }
            }
        }

        if _func.instance != null {
            let mut param: *const QualifiedType = params[0u64];

            if param->sret != null {
                param = params[1u64];
            }

            if param->IsMutable() && !_func.instance_type->IsMutable() && !ignore {
                Logger::Log("Cannot call mutable method '" + _func.Type().Pointee().name + "' on immutable instance.", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            } else {
                args.PushBack(_func.instance);
            }
        }

        while i < values.Size() {
            let mut value: QualifiedValue = values[i];
            let mut index: u64 = params[0u64]->sret != null ? i + 1u64 : i;

            if _func.instance != null {
                index += 1u64;
            }

            if index < params.Size() {
                let param: &QualifiedType = params[index];

                if param.byval != null {
                    if value.Type().IsReference() {
                        value = QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
                    }

                    let mut state: bool = false;

                    if param.byval->IsPointer() && value.Type().IsPointer() {
                        if LLVMGetTypeKind(param.byval->Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(value.Type().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                            state = true;
                        }
                    }

                    if *param.byval != value.Type() && !state {
                        Logger::Log("Incompatible argument types for function '" + _func.Type().Pointee().name + "'. ('" + LLVMTypeToString(param.byval->Value()) + "' != '" + LLVMTypeToString(value.Type().Value()) + "').", node, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }

                    let mut source: QualifiedValue = value;

                    if value.return {
                        source = QualifiedValue(LLVMAddressOf(value.Value(), this.builder), this.type_manager.Pointer(value.Type(), value.Type().IsMutable()));
                    } else {
                        let source_current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
                        LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(LLVMGetBasicBlockParent(source_current)));
                        let source_pointer: LLVMValueRef = LLVMBuildAlloca(this.builder, value.Type().Value(), "");
                        LLVMPositionBuilderAtEnd(this.builder, source_current);
                        LLVMBuildStore(this.builder, value.Value(), source_pointer);
                        source = QualifiedValue(source_pointer, this.type_manager.Pointer(value.Type(), value.Type().IsMutable()), false, true);
                    }

                    let mut _params: Vector<QualifiedValue>;
                    _params.PushBack(source);
                    let current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
                    LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(LLVMGetBasicBlockParent(current)));
                    let pointer: LLVMValueRef = LLVMBuildAlloca(this.builder, source.Type().Pointee().Value(), "");
                    LLVMPositionBuilderAtEnd(this.builder, current);
                    value = QualifiedValue(pointer, source.Type());

                    if value.Type().Pointee().IsClass() {
                        this.CompileConstructor(value.Type().Pointee(), value, _params, node);
                    } else {
                        LLVMBuildStore(this.builder, LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), _params[0u64].Value(), ""), value.Value());
                    }

                    if LLVMGetTypeKind(param.Value()) != LLVMTypeKind::LLVMPointerTypeKind {
                        args.PushBack(LLVMBuildLoad2(this.builder, param.Value(), value.Value(), ""));
                    } else {
                        args.PushBack(value.Value());
                    }
                } else {
                    if value.Type().IsReference() {
                        if param == value.Type().Pointee() {
                            value = QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
                        }
                    }

                    if param.IsReference() {
                        if param.Pointee() == value.Type() {
                            value = QualifiedValue(LLVMAddressOf(value.Value(), this.builder), this.type_manager.Pointer(value.Type(), value.Type().IsMutable()));
                        }
                    }

                    let mut state: bool = false;

                    if param.IsPointer() && value.Type().IsPointer() {
                        if LLVMGetTypeKind(param.Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(value.Type().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                            state = true;
                        }
                    }

                    if param != value.Type() && !state {
                        Logger::Log("Incompatible argument types for function '" + _func.Type().Pointee().name + "'. ('" + LLVMTypeToString(param.Value()) + "' != '" + LLVMTypeToString(value.Type().Value()) + "').", node, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }

                    args.PushBack(value.Value());
                }
            } else {
                if value.Type().IsReference() {
                    value = QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
                } args.PushBack(value.Value());
            } i += 1u64;
        }

        let value: LLVMValueRef = LLVMBuildCall2(this.builder, _func.Type().Pointee().Value(), _func.Value(), args.Data(), args.Size() as u32, "");

        if ret_type.sret != null {
            let current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
            LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(LLVMGetBasicBlockParent(current)));
            let _pointer: LLVMValueRef = LLVMBuildAlloca(this.builder, ret_type.sret->Value(), "");
            return = QualifiedValue(_pointer, this.type_manager.Pointer(ret_type.sret, true), true, true);
            LLVMPositionBuilderAtEnd(this.builder, current);
            LLVMBuildStore(this.builder, value, LLVMBuildBitCast(this.builder, _pointer, LLVMPointerType(ret_type.Value(), 0u32), ""));

            if ret_type.sret->IsClass() {
                this.scope_manager.RegisterInstance(return);
            }
        }

        if return.Null() {
            ret QualifiedValue(value, ret_type);
        } else {
            if !pointer {
                ret QualifiedValue(LLVMBuildLoad2(this.builder, return.Type().Pointee().Value(), return.Value(), ""), return.Type().Pointee(), true);
            } else {
                ret return;
            }
        }
    }

    priv CompileTernary(&mut this, ternary: *const TernaryNode, pointer: bool) -> QualifiedValue {
        let function: LLVMValueRef = LLVMGetBasicBlockParent(LLVMGetInsertBlock(this.builder));
        let mut then_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let mut else_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
        let condition: LLVMValueRef = this.CompileCondition(ternary->condition);

        if condition != null {
            LLVMBuildCondBr(this.builder, condition, then_block, else_block);
        } else {
            ret;
        }

        LLVMPositionBuilderAtEnd(this.builder, then_block);
        let then_value: QualifiedValue = this.CompileExpression(ternary->then_expr, pointer);
        if then_value.Null() { ret QualifiedValue(null, null); }
        then_block = LLVMGetInsertBlock(this.builder);

        LLVMPositionBuilderAtEnd(this.builder, else_block);
        let else_value: QualifiedValue = this.CompileExpression(ternary->else_expr, pointer);
        if else_value.Null() { ret QualifiedValue(null, null); }
        else_block = LLVMGetInsertBlock(this.builder);
        let mut state: bool = false;

        if then_value.Type().IsPointer() && else_value.Type().IsPointer() {
            if LLVMGetTypeKind(then_value.Type().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind || LLVMGetTypeKind(else_value.Type().Pointee().Value()) == LLVMTypeKind::LLVMVoidTypeKind {
                state = true;
            }
        }

        if then_value.Type() != else_value.Type() && !state {
            Logger::Log("Incompatible ternary types. ('" + LLVMTypeToString(then_value.Type().Value()) + "' != '" + LLVMTypeToString(else_value.Type().Value()) + "').", ternary as *const ASTNode, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }

        let merge_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");

        LLVMPositionBuilderAtEnd(this.builder, then_block);
        LLVMBuildBr(this.builder, merge_block);

        LLVMPositionBuilderAtEnd(this.builder, else_block);
        LLVMBuildBr(this.builder, merge_block);

        LLVMPositionBuilderAtEnd(this.builder, merge_block);
        let value: LLVMValueRef = LLVMBuildPhi(this.builder, then_value.Type().Value(), "");

        let blocks[]: LLVMBasicBlockRef = { then_block, else_block };
        let values[]: LLVMValueRef = { then_value.Value(), else_value.Value() };
        LLVMAddIncoming(value, values, blocks, 2u32);

        ret QualifiedValue(value, then_value.Type());
    }

    priv CompileIndexAccess(&mut this, index_access: *const IndexAccessNode, pointer: bool) -> QualifiedValue {
        let mut value: QualifiedValue = this.CompileExpression(index_access->expression, false);

        if value.Null() {
            ret QualifiedValue(null, null);
        }

        let index: QualifiedValue = this.CompileExpression(index_access->index, false);

        if index.Null() {
            ret QualifiedValue(null, null);
        }

        if value.Type().IsReference() {
            value = QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
        }

        if value.Type().IsClass() {
            let mut params: Vector<QualifiedValue>;
            params.PushBack(index);

            // value = QualifiedValue(LLVMAddressOf(value.Value(), this.builder), this.type_manager.Pointer(value.Type(), value.Type().IsMutable()));
            value = this.CompileExpression(index_access->expression, true);

            if value.Null() {
                ret QualifiedValue(null, null);
            }

            if value.Type().Pointee().IsReference() {
                value = QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
            }

            let method: &Pair<Method, *const QualifiedType> = value.Type().Pointee().Get(String("op[]"), this.ValueToType(params), this._class, index_access as *const ASTNode);
            ret this.CompileCall2(QualifiedValue(method.left.value, method.right, value), params, pointer, false, index_access as *const ASTNode);
        }

        if !value.Type().IsPointer() {
            Logger::Log("Index access value must be a pointer.", index_access as *const ASTNode, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }

        let indices[]: LLVMValueRef = { index.Value() };
        let target_pointer: LLVMValueRef = LLVMBuildGEP2(this.builder, value.Type().Pointee().Value(), value.Value(), indices, 1u32, "");
        ret QualifiedValue(target_pointer, this.type_manager.Reference(value.Type().Pointee(), value.Type().IsMutable()));
    }

    priv CompileMemberAccess(&mut this, member_access: *const MemberAccessNode, pointer: bool) -> QualifiedValue {
        let mut instance: QualifiedValue = this.CompileExpression(member_access->expression, true);

        if instance.Null() {
            ret QualifiedValue(null, null);
        }

        if instance.Type().IsPointer() {
            if instance.Type().Pointee().IsReference() {
                instance = QualifiedValue(LLVMBuildLoad2(this.builder, instance.Type().Pointee().Value(), instance.Value(), ""), instance.Type().Pointee(), false, instance.binding);
            }

            if instance.binding || instance.Type().IsReference() {
                if member_access->arrow {
                    instance = QualifiedValue(LLVMBuildLoad2(this.builder, instance.Type().Pointee().Value(), instance.Value(), ""), instance.Type().Pointee(), false, instance.binding);
                }
            } else {
                if !member_access->arrow && !instance.return {
                    Logger::Log("Expected an arrow operator.", member_access as *const ASTNode, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                }
            }
        }

        if !instance.Type().IsPointer() {
            Logger::Log("Member access value must be a pointer.", member_access as *const ASTNode, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }

        if !instance.Type().Pointee().IsClass() && !instance.Type().Pointee().IsEnum() {
            Logger::Log("Cannot access member '" + member_access->member + "' of non-class type.", member_access as *const ASTNode, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }

        let mut state: bool = true;
        let index: i64 = instance.Type().Pointee().IsClass() ? instance.Type().Pointee().Index(member_access->member) : -1i64;
        if this._class != null { state = (*this._class) != instance.Type().Pointee(); }

        if index != -1i64 {
            let field: &Pair<Field, *const QualifiedType> = instance.Type().Pointee().Fields()[member_access->member];

            if field.left.visibility != TokenType::PUBLIC && state {
                Logger::Log("Field '" + member_access->member + "' is private.", member_access as *const ASTNode, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            let field_pointer: LLVMValueRef = LLVMBuildStructGEP2(this.builder, instance.Type().Pointee().Value(), instance.Value(), index as u32, "");

            if !pointer {
                if field.right->IsArray() {
                    let _type: &QualifiedType = this.type_manager.Pointer(field.right->Element(), instance.Type().IsMutable());
                    ret QualifiedValue(LLVMBuildBitCast(this.builder, field_pointer, _type.Value(), ""), _type);
                } else {
                    ret QualifiedValue(LLVMBuildLoad2(this.builder, field.right->Value(), field_pointer, ""), field.right);
                }
            } else {
                ret QualifiedValue(field_pointer, this.type_manager.Pointer(field.right, instance.Type().IsMutable()), false, true);
            }
        } else {
            let method: &Pair<Method, *const QualifiedType> = instance.Type().Pointee().Get(member_access->member, this._class, member_access as *const ASTNode);
            ret QualifiedValue(method.left.value, method.right, instance);
        }
    }

    priv CompileNew(&mut this, _new: *const NewNode) -> QualifiedValue {
        let _type: &QualifiedType = this.CompileType(_new->_type);
        let mut pointer: LLVMValueRef = null;

        if _new->size != null {
            let size: QualifiedValue = this.CompileExpression(_new->size, false);

            if size.Null() {
                ret QualifiedValue(null, null);
            }

            if LLVMGetTypeKind(size.Type().Value()) != LLVMTypeKind::LLVMIntegerTypeKind || LLVMGetIntTypeWidth(size.Type().Value()) != 64u32 || size.Type().IsSigned() {
                Logger::Log("Array size must be of type 'u64'.", _new as *const ASTNode, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            let mut _size: LLVMValueRef = LLVMConstInt(LLVMInt64TypeInContext(this.context), LLVMABISizeOfType(this.layout, _type.Value()), 0i32);
            _size = LLVMBuildAdd(this.builder, LLVMBuildMul(this.builder, _size, size.Value(), ""), LLVMConstInt(LLVMInt64TypeInContext(this.context), 8u64, 0i32), "");
            pointer = LLVMBuildArrayMalloc(this.builder, LLVMInt8TypeInContext(this.context), _size, "");
            LLVMBuildStore(this.builder, size.Value(), LLVMBuildBitCast(this.builder, pointer, LLVMPointerType(LLVMInt64TypeInContext(this.context), 0u32), ""));

            let indices[]: LLVMValueRef = { LLVMConstInt(LLVMInt64TypeInContext(this.context), 8u64, 0i32) };
            pointer = LLVMBuildGEP2(this.builder, LLVMInt8TypeInContext(this.context), pointer, indices, 1u32, "");
            pointer = LLVMBuildBitCast(this.builder, pointer, LLVMPointerType(_type.Value(), 0u32), "");

            if _type.IsClass() {
                let value: LLVMValueRef = LLVMBuildAlloca(this.builder, LLVMInt64TypeInContext(this.context), "");
                LLVMBuildStore(this.builder, LLVMConstInt(LLVMInt64TypeInContext(this.context), 0u64, 0i32), value);

                let function: LLVMValueRef = LLVMGetBasicBlockParent(LLVMGetInsertBlock(this.builder));
                let compare_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
                let loop_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
                let end_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");

                LLVMBuildBr(this.builder, compare_block);
                LLVMPositionBuilderAtStart(this.builder, compare_block);
                let index: LLVMValueRef = LLVMBuildLoad2(this.builder, LLVMInt64TypeInContext(this.context), value, "");
                LLVMBuildCondBr(this.builder, LLVMBuildICmp(this.builder, LLVMIntPredicate::LLVMIntULT, index, size.Value(), ""), loop_block, end_block);

                let params: Vector<QualifiedValue>;
                let indices[]: LLVMValueRef = { index };
                LLVMPositionBuilderAtStart(this.builder, loop_block);
                this.CompileConstructor(_type, QualifiedValue(LLVMBuildGEP2(this.builder, _type.Value(), pointer, indices, 1u32, ""), this.type_manager.Pointer(_type, true)), params, _new as *const ASTNode);
                LLVMBuildStore(this.builder, LLVMBuildAdd(this.builder, index, LLVMConstInt(LLVMInt64TypeInContext(this.context), 1u64, 0i32), ""), value);
                LLVMBuildBr(this.builder, compare_block);
                LLVMPositionBuilderAtStart(this.builder, end_block);
            }
        } else {
            let mut values: Vector<QualifiedValue>;
            pointer = LLVMBuildMalloc(this.builder, _type.Value(), "");
            let mut i: u64 = 0u64;
            
            while _new->arguments.Size() > i {
                let value: QualifiedValue = this.CompileExpression(_new->arguments[i], false);

                if !value.Null() {
                    values.PushBack(value);
                } else {
                    ret QualifiedValue(null, null);
                } i += 1u64;
            }

            if _type.IsClass() {
                this.CompileConstructor(_type, QualifiedValue(pointer, this.type_manager.Pointer(_type, true)), values, _new as *const ASTNode);
            } else if !values.Empty() {
                Logger::Log("Cannot initialize non-class types with parameters.", _new as *const ASTNode, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }
        }

        ret QualifiedValue(pointer, this.type_manager.Pointer(_type, true));
    }

    priv CompileDelete(&mut this, delete: *const DeleteNode) -> QualifiedValue {
        let mut pointer: QualifiedValue = this.CompileExpression(delete->expression, false);

        if pointer.Null() {
            ret QualifiedValue(null, null);
        }

        if pointer.Type().IsReference() {
            pointer = QualifiedValue(LLVMBuildLoad2(this.builder, pointer.Type().Pointee().Value(), pointer.Value(), ""), pointer.Type().Pointee());
        }

        if !pointer.Type().IsPointer() {
            Logger::Log("Delete value must be a pointer.", delete as *const ASTNode, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }

        let mut _pointer: LLVMValueRef = pointer.Value();

        if LLVMGetTypeKind(pointer.Type().Pointee().Value()) != LLVMTypeKind::LLVMIntegerTypeKind || LLVMGetIntTypeWidth(pointer.Type().Pointee().Value()) != 8u32 {
            _pointer = LLVMBuildBitCast(this.builder, _pointer, LLVMPointerType(LLVMInt8TypeInContext(this.context), 0u32), "");
        }

        if delete->array {
            let indices[]: LLVMValueRef = { LLVMConstInt(LLVMInt64TypeInContext(this.context), -8i64 as u64, 0i32) };
            _pointer = LLVMBuildGEP2(this.builder, LLVMInt8TypeInContext(this.context), _pointer, indices, 1u32, "");

            if pointer.Type().Pointee().IsClass() {
                let count: LLVMValueRef = LLVMBuildLoad2(this.builder, LLVMInt64TypeInContext(this.context), LLVMBuildBitCast(this.builder, _pointer, LLVMPointerType(LLVMInt64TypeInContext(this.context), 0u32), ""), "");

                let value: LLVMValueRef = LLVMBuildAlloca(this.builder, LLVMInt64TypeInContext(this.context), "");
                LLVMBuildStore(this.builder, LLVMConstInt(LLVMInt64TypeInContext(this.context), 0u64, 0i32), value);

                let function: LLVMValueRef = LLVMGetBasicBlockParent(LLVMGetInsertBlock(this.builder));
                let compare_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
                let loop_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");
                let end_block: LLVMBasicBlockRef = LLVMAppendBasicBlockInContext(this.context, function, "");

                LLVMBuildBr(this.builder, compare_block);
                LLVMPositionBuilderAtStart(this.builder, compare_block);
                let index: LLVMValueRef = LLVMBuildLoad2(this.builder, LLVMInt64TypeInContext(this.context), value, "");
                LLVMBuildCondBr(this.builder, LLVMBuildICmp(this.builder, LLVMIntPredicate::LLVMIntULT, index, count, ""), loop_block, end_block);

                let indices[]: LLVMValueRef = { index };
                LLVMPositionBuilderAtStart(this.builder, loop_block);
                this.CompileDestructor(pointer.Type().Pointee(), QualifiedValue(LLVMBuildGEP2(this.builder, pointer.Type().Pointee().Value(), pointer.Value(), indices, 1u32, ""), pointer.Type()), delete as *const ASTNode);
                LLVMBuildStore(this.builder, LLVMBuildAdd(this.builder, index, LLVMConstInt(LLVMInt64TypeInContext(this.context), 1u64, 0i32), ""), value);
                LLVMBuildBr(this.builder, compare_block);
                LLVMPositionBuilderAtStart(this.builder, end_block);
            }
        } else {
            if pointer.Type().Pointee().IsClass() {
                this.CompileDestructor(pointer.Type().Pointee(), pointer, delete as *const ASTNode);
            }
        }

        LLVMBuildFree(this.builder, _pointer);
        ret QualifiedValue(null, null);
    }

    priv CompileCast(&mut this, cast: *const CastNode, pointer: bool) -> QualifiedValue {
        let mut target: *const QualifiedType = this.CompileType(cast->target_type);

        if cast->expression->node_type != ASTNodeType::INITIALIZER_LIST {
            if pointer {
                target = this.type_manager.Pointer(target, target->IsMutable());
            }

            let value: QualifiedValue = this.CompileExpression(cast->expression, pointer);

            if !value.Null() {
                ret this.CompileCast2(value, target, cast as *const ASTNode);
            } else {
                ret QualifiedValue(null, null);
            }
        } else {
            if !target->IsClass() {
                Logger::Log("Expected a class.", cast as *const ASTNode, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            let mut params: Vector<QualifiedValue>;
            let initializer_list: *const InitializerListNode = cast->expression as *const InitializerListNode;
            let mut i: u64 = 0u64;

            while i < initializer_list->expressions.Size() {
                let value: QualifiedValue = this.CompileExpression(initializer_list->expressions[i], false);

                if !value.Null() {
                    params.PushBack(value);
                } else {
                    ret QualifiedValue(null, null);
                } i += 1u64;
            }

            let current: LLVMBasicBlockRef = LLVMGetInsertBlock(this.builder);
            LLVMPositionBuilderAtStart(this.builder, LLVMGetEntryBasicBlock(LLVMGetBasicBlockParent(current)));
            let _pointer: LLVMValueRef = LLVMBuildAlloca(this.builder, target->Value(), "");
            LLVMPositionBuilderAtEnd(this.builder, current);
            let instance: QualifiedValue = QualifiedValue(_pointer, this.type_manager.Pointer(target, false), false, true);
            this.CompileConstructor(target, instance, params, cast as *const ASTNode);
            this.scope_manager.RegisterInstance(instance);

            if !pointer {
                ret QualifiedValue(LLVMBuildLoad2(this.builder, target->Value(), instance.Value(), ""), target);
            } else {
                ret instance;
            }
        }
    }

    priv CompileCast2(&mut this, value: QualifiedValue, target: &QualifiedType, node: *const ASTNode) -> QualifiedValue {
        let target_kind: LLVMTypeKind = LLVMGetTypeKind(target.Value());
        let value_kind: LLVMTypeKind = LLVMGetTypeKind(value.Type().Value());

        if value.Type() == target {
            Logger::Log("Redundant cast. ('" + LLVMTypeToString(value.Type().Value()) + "' to '" + LLVMTypeToString(target.Value()) + "')", node, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }

        if value.Type().IsPointer() && target_kind == LLVMTypeKind::LLVMIntegerTypeKind {
            ret QualifiedValue(LLVMBuildPtrToInt(this.builder, value.Value(), target.Value(), ""), target);
        } else if value_kind == LLVMTypeKind::LLVMFloatTypeKind {
            if target_kind == LLVMTypeKind::LLVMIntegerTypeKind {
                if target.IsSigned() {
                    ret QualifiedValue(LLVMBuildFPToSI(this.builder, value.Value(), target.Value(), ""), target);
                } else {
                    ret QualifiedValue(LLVMBuildFPToUI(this.builder, value.Value(), target.Value(), ""), target);
                }
            }

            if target_kind == LLVMTypeKind::LLVMDoubleTypeKind {
                ret QualifiedValue(LLVMBuildFPExt(this.builder, value.Value(), target.Value(), ""), target);
            }
        } else if value_kind == LLVMTypeKind::LLVMDoubleTypeKind {
            if target_kind == LLVMTypeKind::LLVMIntegerTypeKind {
                if target.IsSigned() {
                    ret QualifiedValue(LLVMBuildFPToSI(this.builder, value.Value(), target.Value(), ""), target);
                } else {
                    ret QualifiedValue(LLVMBuildFPToUI(this.builder, value.Value(), target.Value(), ""), target);
                }
            }
            
            if target_kind == LLVMTypeKind::LLVMFloatTypeKind {
                ret QualifiedValue(LLVMBuildFPTrunc(this.builder, value.Value(), target.Value(), ""), target);
            }
        } else if value_kind == LLVMTypeKind::LLVMIntegerTypeKind {
            if target.IsPointer() {
                ret QualifiedValue(LLVMBuildIntToPtr(this.builder, value.Value(), target.Value(), ""), target);
            }

            if target_kind == LLVMTypeKind::LLVMFloatTypeKind || target_kind == LLVMTypeKind::LLVMDoubleTypeKind {
                if value.Type().IsSigned() {
                    ret QualifiedValue(LLVMBuildSIToFP(this.builder, value.Value(), target.Value(), ""), target);
                } else {
                    ret QualifiedValue(LLVMBuildUIToFP(this.builder, value.Value(), target.Value(), ""), target);
                }
            }

            if target_kind == LLVMTypeKind::LLVMIntegerTypeKind {
                let value_width: u32 = LLVMGetIntTypeWidth(value.Type().Value());
                let target_width: u32 = LLVMGetIntTypeWidth(target.Value());

                if target_width > value_width {
                    if value.Type().IsSigned() {
                        ret QualifiedValue(LLVMBuildSExt(this.builder, value.Value(), target.Value(), ""), target);
                    } else {
                        ret QualifiedValue(LLVMBuildZExt(this.builder, value.Value(), target.Value(), ""), target);
                    }
                } else if target_width < value_width {
                    ret QualifiedValue(LLVMBuildTrunc(this.builder, value.Value(), target.Value(), ""), target);
                } else {
                    ret QualifiedValue(value.Value(), target);
                }
            }
        }

        if value.Type().IsPointer() && target.IsPointer() {
            let mut pointer: LLVMValueRef = value.Value();

            if value.Type().Pointee().IsClass() && target.Pointee().IsClass() {
                let value_class: &QualifiedType = value.Type().Pointee();
                let target_class: &QualifiedType = target.Pointee();

                let value_fields: &mut Map<String, Pair<Field, *const QualifiedType>> = value_class.Fields();
                let target_fields: &mut Map<String, Pair<Field, *const QualifiedType>> = target_class.Fields();
                let (mut related: bool, mut index: u32) = (false, 0u32);
                let (mut i: u64, mut j: u64) = (0u64, 0u64);

                while value_fields.Size() > i && !related {
                    if value_fields[i].left == target_class.name {
                        (related, index) = (true, i as u32);
                        break;
                    } i += 1u64;
                }

                while target_fields.Size() > j && !related {
                    if target_fields[j].left == value_class.name {
                        (related, index) = (true, -(j as i64) as u32);
                        break;
                    } j += 1u64;
                }

                if !related {
                    Logger::Log("Cannot cast class '" + value_class.name + "' to unrelated class '" + target_class.name + "'.", node, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                }

                if index != 0u32 {
                    pointer = LLVMBuildStructGEP2(this.builder, value.Type().Pointee().Value(), value.Value(), index, "");
                }
            }

            ret QualifiedValue(LLVMBuildBitCast(this.builder, pointer, target.Value(), ""), target, false, value.binding);
        } else {
            Logger::Log("Cannot cast '" + LLVMTypeToString(value.Type().Value()) + "' to '" + LLVMTypeToString(target.Value()) + "'.", node, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }
    }

    priv CompileUnaryOperation(&mut this, unary_op: *const UnaryOpNode, pointer: bool) -> QualifiedValue {
        if unary_op->operator == TokenType::BITWISE_AND {
            let _pointer: QualifiedValue = this.CompileExpression(unary_op->operand, true);

            if _pointer.Null() {
                ret QualifiedValue(null, null);
            }

            if _pointer.Type().Pointee().IsReference() {
                let _type: *const QualifiedType = this.type_manager.Pointer(_pointer.Type().Pointee().Pointee(), unary_op->mutable);
                ret QualifiedValue(LLVMBuildLoad2(this.builder, _pointer.Type().Pointee().Value(), _pointer.Value(), ""), _type);
            } else {
                ret QualifiedValue(_pointer.Value(), this.type_manager.Copy(_pointer.Type(), unary_op->mutable));
            }
        } else {
            let mut value: QualifiedValue = this.CompileExpression(unary_op->operand, false);

            if value.Null() {
                ret QualifiedValue(null, null);
            }

            if value.Type().IsReference() {
                value = QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
            }

            let kind: LLVMTypeKind = LLVMGetTypeKind(value.Type().Value());

            if unary_op->operator == TokenType::MUL {
                if value.Type().IsPointer() {
                    if !pointer {
                        ret QualifiedValue(LLVMBuildLoad2(this.builder, value.Type().Pointee().Value(), value.Value(), ""), value.Type().Pointee());
                    } else {
                        ret value;
                    }
                } else {
                    Logger::Log("Cannot dereference non-pointer type '" + LLVMTypeToString(value.Type().Value()) + "'.", unary_op as *const ASTNode, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                }
            } else if unary_op->operator == TokenType::MINUS {
                if kind == LLVMTypeKind::LLVMIntegerTypeKind {
                    if value.Type().IsSigned() {
                        ret QualifiedValue(LLVMBuildNeg(this.builder, value.Value(), ""), value.Type());
                    } else {
                        Logger::Log("Cannot negate unsigned type '" + LLVMTypeToString(value.Type().Value()) + "'.", unary_op as *const ASTNode, LogSeverity::Error);
                        ret QualifiedValue(null, null);
                    }
                } else if kind == LLVMTypeKind::LLVMFloatTypeKind || kind == LLVMTypeKind::LLVMDoubleTypeKind {
                    ret QualifiedValue(LLVMBuildFNeg(this.builder, value.Value(), ""), value.Type());
                } else {
                    Logger::Log("Cannot negate type '" + LLVMTypeToString(value.Type().Value()) + "'.", unary_op as *const ASTNode, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                }
            } else if unary_op->operator == TokenType::NOT {
                if kind == LLVMTypeKind::LLVMIntegerTypeKind {
                    ret QualifiedValue(LLVMBuildNot(this.builder, value.Value(), ""), value.Type());
                } else {
                    Logger::Log("Cannot invert type '" + LLVMTypeToString(value.Type().Value()) + "'.", unary_op as *const ASTNode, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                }
            } else {
                Logger::Log("Invalid unary operation '" + unary_op->operator.ToString() + "'.", unary_op as *const ASTNode, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }
        }
    }

    priv CompileBinaryOperation(&mut this, binary_op: *const BinaryOpNode, pointer: bool) -> QualifiedValue {
        let left: QualifiedValue = this.CompileExpression(binary_op->left, false);
        
        if left.Null() {
            ret QualifiedValue(null, null);
        }

        let right: QualifiedValue = this.CompileExpression(binary_op->right, false);

        if right.Null() {
            ret QualifiedValue(null, null);
        }

        ret this.CompileBinaryOperation2(left, right, binary_op->operator, pointer, binary_op as *const ASTNode);
    }

    priv CompileBinaryOperation2(&mut this, mut left: QualifiedValue, mut right: QualifiedValue, operator: TokenType, pointer: bool, node: *const ASTNode) -> QualifiedValue {
        if left.Type().IsReference() {
            left = QualifiedValue(LLVMBuildLoad2(this.builder, left.Type().Pointee().Value(), left.Value(), ""), left.Type().Pointee());
        }

        if right.Type().IsReference() {
            right = QualifiedValue(LLVMBuildLoad2(this.builder, right.Type().Pointee().Value(), right.Value(), ""), right.Type().Pointee());
        }

        let mut method_name: String = "op";
        method_name += operator.ToBinaryOperatorString();

        let mut values: Vector<QualifiedValue>;
        values.PushBack(left);
        values.PushBack(right);

        let symbol: *const Symbol = this.scope_manager.Resolve(method_name, this.ValueToType(values), node, true);

        if symbol != null {
            ret this.CompileCall2(symbol->value, values, pointer, false, node);
        }

        if left.Type().IsClass() || right.Type().IsClass() {
            let value: &QualifiedValue = left.Type().IsClass() ? &right : &left;
            let instance: &QualifiedValue = left.Type().IsClass() ? &left : &right;

            let mut values: Vector<QualifiedValue>;
            values.PushBack(value);

            let param_types: Vector<*const QualifiedType> = this.ValueToType(values);
            let _class: &QualifiedType = instance.Type();

            if _class.Has(method_name, param_types, this._class) {
                let method: &Pair<Method, *const QualifiedType> = _class.Get(method_name, param_types, this._class, node);
                let _instance: QualifiedValue = QualifiedValue(LLVMAddressOf(instance.Value(), this.builder), this.type_manager.Pointer(instance.Type(), instance.Type().IsMutable()));
                ret this.CompileCall2(QualifiedValue(method.left.value, method.right, _instance), values, pointer, false, node);
            }

            if left.Type() == right.Type() {
                if operator != TokenType::EQUAL && operator != TokenType::NOT_EQUAL {
                    Logger::Log("Invalid class binary operation '" + operator.ToString() + "' for type '" + LLVMTypeToString(_class.Value()) + "'.", node, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                }

                let fields: &mut Map<String, Pair<Field, *const QualifiedType>> = _class.Fields();
                left = QualifiedValue(LLVMAddressOf(left.Value(), this.builder), this.type_manager.Pointer(left.Type(), true));
                right = QualifiedValue(LLVMAddressOf(right.Value(), this.builder), this.type_manager.Pointer(right.Type(), true));
                let mut result: LLVMValueRef = null;
                let mut i: u64 = 0u64;

                while i < fields.Size() {
                    let field: &mut Pair<String, Pair<Field, *const QualifiedType>> = fields[i];
                    let left: QualifiedValue = QualifiedValue(LLVMBuildLoad2(this.builder, field.right.right->Value(), LLVMBuildStructGEP2(this.builder, left.Type().Pointee().Value(), left.Value(), _class.Index(field.left) as u32, ""), ""), field.right.right);
                    let right: QualifiedValue = QualifiedValue(LLVMBuildLoad2(this.builder, field.right.right->Value(), LLVMBuildStructGEP2(this.builder, right.Type().Pointee().Value(), right.Value(), _class.Index(field.left) as u32, ""), ""), field.right.right);
                    let _result: LLVMValueRef = this.CompileBinaryOperation2(left, right, operator, pointer, node).Value();

                    if result != null {
                        result = LLVMBuildAnd(this.builder, result, _result, "");
                    } else {
                        result = _result;
                    } i += 1u64;
                }

                if operator == TokenType::NOT_EQUAL {
                    result = LLVMBuildNot(this.builder, result, "");
                }

                ret QualifiedValue(result, this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else {
                Logger::Log("Incompatible class binary operation types. ('" + LLVMTypeToString(_class.Value()) + "' != '" + LLVMTypeToString(value.Type().Value()) + "').", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }
        }

        let (left_kind: LLVMTypeKind, right_kind: LLVMTypeKind) = (LLVMGetTypeKind(left.Type().Value()), LLVMGetTypeKind(right.Type().Value()));

        if left.Type().IsPointer() && right.Type().IsPointer() {
            if operator == TokenType::MINUS {
                let _type: &QualifiedType = this.type_manager.Primitive(LLVMInt64TypeInContext(this.context), false);
                ret QualifiedValue(LLVMBuildSub(this.builder, LLVMBuildPtrToInt(this.builder, left.Value(), _type.Value(), ""), LLVMBuildPtrToInt(this.builder, right.Value(), _type.Value(), ""), ""), _type);
            } else if operator == TokenType::EQUAL {
                ret QualifiedValue(LLVMBuildICmp(this.builder, LLVMIntPredicate::LLVMIntEQ, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::NOT_EQUAL {
                ret QualifiedValue(LLVMBuildICmp(this.builder, LLVMIntPredicate::LLVMIntNE, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::GREATER {
                ret QualifiedValue(LLVMBuildICmp(this.builder, LLVMIntPredicate::LLVMIntUGT, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::GREATER_EQUAL {
                ret QualifiedValue(LLVMBuildICmp(this.builder, LLVMIntPredicate::LLVMIntUGE, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::LESS {
                ret QualifiedValue(LLVMBuildICmp(this.builder, LLVMIntPredicate::LLVMIntULT, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::LESS_EQUAL {
                ret QualifiedValue(LLVMBuildICmp(this.builder, LLVMIntPredicate::LLVMIntULE, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else {
                Logger::Log("Invalid pointer binary operation '" + operator.ToString() + "' for type '" + LLVMTypeToString(left.Type().Value()) + "'.", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }
        } else if (left.Type().IsPointer() && right_kind == LLVMTypeKind::LLVMIntegerTypeKind) || (left_kind == LLVMTypeKind::LLVMIntegerTypeKind && right.Type().IsPointer()) {
            let ptr: &QualifiedValue = left.Type().IsPointer() ? &left : &right;
            let index: &QualifiedValue = left.Type().IsPointer() ? &right : &left;
            let width: u32 = LLVMGetIntTypeWidth(index.Type().Value());

            if width == 64u32 {
                if operator == TokenType::PLUS {
                    let indices[]: LLVMValueRef = { index.Value() };
                    ret QualifiedValue(LLVMBuildGEP2(this.builder, ptr.Type().Pointee().Value(), ptr.Value(), indices, 1u32, ""), ptr.Type());
                } else if operator == TokenType::MINUS {
                    let indices[]: LLVMValueRef = { LLVMBuildNeg(this.builder, index.Value(), "") };
                    ret QualifiedValue(LLVMBuildGEP2(this.builder, ptr.Type().Pointee().Value(), ptr.Value(), indices, 1u32, ""), ptr.Type());
                } else {
                    Logger::Log("Invalid pointer binary operation '" + operator.ToString() + "' for type '" + LLVMTypeToString(left.Type().Value()) + "'.", node, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                }
            } else {
                Logger::Log("Invalid index type '" + LLVMTypeToString(index.Type().Value()) + "'.", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }
        } else if left_kind == LLVMTypeKind::LLVMIntegerTypeKind && right_kind == LLVMTypeKind::LLVMIntegerTypeKind {
            if left.Type() != right.Type() {
                Logger::Log("Incompatible binary operation types. ('" + LLVMTypeToString(left.Type().Value()) + "' != '" + LLVMTypeToString(right.Type().Value()) + "').", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            if operator == TokenType::PLUS {
                ret QualifiedValue(LLVMBuildAdd(this.builder, left.Value(), right.Value(), ""), left.Type());
            } else if operator == TokenType::MINUS {
                ret QualifiedValue(LLVMBuildSub(this.builder, left.Value(), right.Value(), ""), left.Type());
            } else if operator == TokenType::MUL {
                ret QualifiedValue(LLVMBuildMul(this.builder, left.Value(), right.Value(), ""), left.Type());
            } else if operator == TokenType::DIV {
                if left.Type().IsSigned() {
                    ret QualifiedValue(LLVMBuildSDiv(this.builder, left.Value(), right.Value(), ""), left.Type());
                } else {
                    ret QualifiedValue(LLVMBuildUDiv(this.builder, left.Value(), right.Value(), ""), left.Type());
                }
            } else if operator == TokenType::MOD {
                if left.Type().IsSigned() {
                    ret QualifiedValue(LLVMBuildSRem(this.builder, left.Value(), right.Value(), ""), left.Type());
                } else {
                    ret QualifiedValue(LLVMBuildURem(this.builder, left.Value(), right.Value(), ""), left.Type());
                }
            } else if operator == TokenType::EQUAL {
                ret QualifiedValue(LLVMBuildICmp(this.builder, LLVMIntPredicate::LLVMIntEQ, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::NOT_EQUAL {
                ret QualifiedValue(LLVMBuildICmp(this.builder, LLVMIntPredicate::LLVMIntNE, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::GREATER {
                ret QualifiedValue(LLVMBuildICmp(this.builder, left.Type().IsSigned() ? LLVMIntPredicate::LLVMIntSGT : LLVMIntPredicate::LLVMIntUGT, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::GREATER_EQUAL {
                ret QualifiedValue(LLVMBuildICmp(this.builder, left.Type().IsSigned() ? LLVMIntPredicate::LLVMIntSGE : LLVMIntPredicate::LLVMIntUGE, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::LESS {
                ret QualifiedValue(LLVMBuildICmp(this.builder, left.Type().IsSigned() ? LLVMIntPredicate::LLVMIntSLT : LLVMIntPredicate::LLVMIntULT, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::LESS_EQUAL {
                ret QualifiedValue(LLVMBuildICmp(this.builder, left.Type().IsSigned() ? LLVMIntPredicate::LLVMIntSLE : LLVMIntPredicate::LLVMIntULE, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::AND || operator == TokenType::BITWISE_AND {
                if LLVMGetIntTypeWidth(left.Type().Value()) != 1u32 && operator == TokenType::AND {
                    Logger::Log("Invalid type '" + LLVMTypeToString(left.Type().Value()) + "' for binary operation '" + operator.ToString() + "'.", node, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                } else {
                    ret QualifiedValue(LLVMBuildAnd(this.builder, left.Value(), right.Value(), ""), left.Type());
                }
            } else if operator == TokenType::OR || operator == TokenType::BITWISE_OR {
                if LLVMGetIntTypeWidth(left.Type().Value()) != 1u32 && operator == TokenType::OR {
                    Logger::Log("Invalid type '" + LLVMTypeToString(left.Type().Value()) + "' for binary operation '" + operator.ToString() + "'.", node, LogSeverity::Error);
                    ret QualifiedValue(null, null);
                } else {
                    ret QualifiedValue(LLVMBuildOr(this.builder, left.Value(), right.Value(), ""), left.Type());
                }
            } else if operator == TokenType::BITWISE_XOR {
                ret QualifiedValue(LLVMBuildXor(this.builder, left.Value(), right.Value(), ""), left.Type());
            } else if operator == TokenType::LSHIFT {
                ret QualifiedValue(LLVMBuildShl(this.builder, left.Value(), right.Value(), ""), left.Type());
            } else if operator == TokenType::RSHIFT {
                if left.Type().IsSigned() {
                    ret QualifiedValue(LLVMBuildAShr(this.builder, left.Value(), right.Value(), ""), left.Type());
                } else {
                    ret QualifiedValue(LLVMBuildLShr(this.builder, left.Value(), right.Value(), ""), left.Type());
                }
            } else {
                Logger::Log("Invalid binary operation '" + operator.ToString() + "' for type '" + LLVMTypeToString(left.Type().Value()) + "'.", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }
        } else if (left_kind == LLVMTypeKind::LLVMFloatTypeKind || left_kind == LLVMTypeKind::LLVMDoubleTypeKind) && (right_kind == LLVMTypeKind::LLVMFloatTypeKind || right_kind == LLVMTypeKind::LLVMDoubleTypeKind) {
            if left.Type() != right.Type() {
                Logger::Log("Incompatible binary operation types. ('" + LLVMTypeToString(left.Type().Value()) + "' != '" + LLVMTypeToString(right.Type().Value()) + "').", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }

            if operator == TokenType::PLUS {
                ret QualifiedValue(LLVMBuildFAdd(this.builder, left.Value(), right.Value(), ""), left.Type());
            } else if operator == TokenType::MINUS {
                ret QualifiedValue(LLVMBuildFSub(this.builder, left.Value(), right.Value(), ""), left.Type());
            } else if operator == TokenType::MUL {
                ret QualifiedValue(LLVMBuildFMul(this.builder, left.Value(), right.Value(), ""), left.Type());
            } else if operator == TokenType::DIV {
                ret QualifiedValue(LLVMBuildFDiv(this.builder, left.Value(), right.Value(), ""), left.Type());
            } else if operator == TokenType::MOD {
                ret QualifiedValue(LLVMBuildFRem(this.builder, left.Value(), right.Value(), ""), left.Type());
            } else if operator == TokenType::EQUAL {
                ret QualifiedValue(LLVMBuildFCmp(this.builder, LLVMRealPredicate::LLVMRealOEQ, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::NOT_EQUAL {
                ret QualifiedValue(LLVMBuildFCmp(this.builder, LLVMRealPredicate::LLVMRealONE, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::GREATER {
                ret QualifiedValue(LLVMBuildFCmp(this.builder, LLVMRealPredicate::LLVMRealOGT, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::GREATER_EQUAL {
                ret QualifiedValue(LLVMBuildFCmp(this.builder, LLVMRealPredicate::LLVMRealOGE, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::LESS {
                ret QualifiedValue(LLVMBuildFCmp(this.builder, LLVMRealPredicate::LLVMRealOLT, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else if operator == TokenType::LESS_EQUAL {
                ret QualifiedValue(LLVMBuildFCmp(this.builder, LLVMRealPredicate::LLVMRealOLE, left.Value(), right.Value(), ""), this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false));
            } else {
                Logger::Log("Invalid binary operation '" + operator.ToString() + "' for type '" + LLVMTypeToString(left.Type().Value()) + "'.", node, LogSeverity::Error);
                ret QualifiedValue(null, null);
            }
        } else {
            Logger::Log("Invalid type '" + LLVMTypeToString(left.Type().Value()) + "' for binary operation '" + operator.ToString() + "'.", node, LogSeverity::Error);
            ret QualifiedValue(null, null);
        }
    }

    priv CompileInlineAsm(&mut this, inline_asm: *const InlineAsmNode) {
        if this.scope_manager.current->global {
            if !inline_asm->inputs.Empty() {
                Logger::Log("Cannot set inputs on module inline assembly.", inline_asm as *const ASTNode, LogSeverity::Error);
            }

            if !inline_asm->outputs.Empty() {
                Logger::Log("Cannot set outputs on module inline assembly.", inline_asm as *const ASTNode, LogSeverity::Error);
            }

            if !inline_asm->clobbers.Empty() {
                Logger::Log("Cannot set clobbers on module inline assembly.", inline_asm as *const ASTNode, LogSeverity::Error);
            }

            LLVMSetModuleInlineAsm(this.module, inline_asm->code.Data());
        } else {
            let mut types: Vector<LLVMTypeRef>;
            let mut values: Vector<LLVMValueRef>;
            let mut output: QualifiedValue;
            let mut constraints: String;
            let mut i: u64 = 0u64;

            while i < inline_asm->outputs.Size() {
                if !constraints.Empty() { constraints += ","; }
                constraints += "={";
                constraints += inline_asm->outputs[i].left;
                constraints += "}";

                if !output.Null() {
                    Logger::Log("Output already set.", inline_asm->outputs[i].right, LogSeverity::Error);
                }

                output = this.CompileExpression(inline_asm->outputs[i].right, true);
                if output.Null() { ret; }
                i += 1u64;
            }

            let mut j: u64 = 0u64;

            while j < inline_asm->inputs.Size() {
                if !constraints.Empty() { constraints += ","; }
                constraints += "{";
                constraints += inline_asm->inputs[j].left;
                constraints += "}";
                let value: QualifiedValue = this.CompileExpression(inline_asm->inputs[j].right, false);
                if value.Null() { ret; }
                types.PushBack(value.Type().Value());
                values.PushBack(value.Value());
                j += 1u64;
            }

            let mut k: u64 = 0u64;

            while k < inline_asm->clobbers.Size() {
                if !constraints.Empty() { constraints += ","; }
                constraints += "~{";
                constraints += inline_asm->clobbers[k];
                constraints += "}";
                k += 1u64;
            }

            let func_type: LLVMTypeRef = LLVMFunctionType(!output.Null() ? output.Type().Pointee().Value() : LLVMVoidTypeInContext(this.context), types.Empty() ? null : types.Data(), types.Size() as u32, 0i32);
            let _inline_asm: LLVMValueRef = LLVMGetInlineAsm(func_type, inline_asm->code.Data(), inline_asm->code.Length(), constraints.Data(), constraints.Length(), inline_asm->_volatile as i32, 0i32, LLVMInlineAsmDialect::LLVMInlineAsmDialectIntel, 0i32);
            let result: LLVMValueRef = LLVMBuildCall2(this.builder, func_type, _inline_asm, values.Empty() ? null : values.Data(), values.Size() as u32, "");

            if !output.Null() {
                LLVMBuildStore(this.builder, result, output.Value());
            }
        }
    }

    priv CompileType(&mut this, type_node: *const ASTNode) -> &QualifiedType {
        if type_node->node_type == ASTNodeType::PRIMITIVE_TYPE {
            let primitive_type: *const PrimitiveTypeNode = type_node as *const PrimitiveTypeNode;

            if primitive_type->name == "bool" {
                ret this.type_manager.Primitive(LLVMInt1TypeInContext(this.context), false);
            } else if primitive_type->name == "i8" || primitive_type->name == "u8" {
                ret this.type_manager.Primitive(LLVMInt8TypeInContext(this.context), primitive_type->name[0u64] != 'u' ? true : false);
            } else if primitive_type->name == "i16" || primitive_type->name == "u16" {
                ret this.type_manager.Primitive(LLVMInt16TypeInContext(this.context), primitive_type->name[0u64] != 'u' ? true : false);
            } else if primitive_type->name == "i32" || primitive_type->name == "u32" || primitive_type->name == "char" {
                ret this.type_manager.Primitive(LLVMInt32TypeInContext(this.context), primitive_type->name[0u64] != 'u' ? true : false);
            } else if primitive_type->name == "i64" || primitive_type->name == "u64" {
                ret this.type_manager.Primitive(LLVMInt64TypeInContext(this.context), primitive_type->name[0u64] != 'u' ? true : false);
            } else if primitive_type->name == "i128" || primitive_type->name == "u128" {
                ret this.type_manager.Primitive(LLVMInt128TypeInContext(this.context), primitive_type->name[0u64] != 'u' ? true : false);
            } else if primitive_type->name == "f32" {
                ret this.type_manager.Primitive(LLVMFloatTypeInContext(this.context), false);
            } else if primitive_type->name == "f64" {
                ret this.type_manager.Primitive(LLVMDoubleTypeInContext(this.context), false);
            } else if primitive_type->name == "void" {
                ret this.type_manager.Primitive(LLVMVoidTypeInContext(this.context), false);
            } else {
                if this.scope_manager.Has(primitive_type->name, SymbolKind::Type) {
                    ret this.scope_manager.Get(primitive_type->name, SymbolKind::Type)->value.Type();
                } else if this.scope_manager.Has(primitive_type->name, SymbolKind::Class) {
                    ret this.scope_manager.Get(primitive_type->name, SymbolKind::Class)->value.Type();
                } else if this.scope_manager.Has(primitive_type->name, SymbolKind::Generic) {
                    if primitive_type->generic {
                        let mut types: Vector<*const QualifiedType>;
                        let mut i: u64 = 0u64;

                        while i < primitive_type->types.Size() {
                            types.PushBack(this.CompileType(primitive_type->types[i]));
                            i += 1u64;
                        }

                        ret (this.scope_manager.Get(primitive_type->name, SymbolKind::Generic)->pointer as *mut Generic)->Get(types).left;
                    } else {
                        Logger::Log("Generic type '" + primitive_type->name + "' requires parameters.", type_node, LogSeverity::Error);
                        ret null;
                    }
                } else {
                    Logger::Log("Type '" + primitive_type->name + "' not found.", type_node, LogSeverity::Error);
                    ret null;
                }
            }
        } else if type_node->node_type == ASTNodeType::POINTER_TYPE {
            let pointer_type: *const PointerTypeNode = type_node as *const PointerTypeNode;
            ret this.type_manager.Pointer(this.CompileType(pointer_type->base_type), pointer_type->mutable);
        } else if type_node->node_type == ASTNodeType::REFERENCE_TYPE {
            let reference_type: *const ReferenceTypeNode = type_node as *const ReferenceTypeNode;
            ret this.type_manager.Reference(this.CompileType(reference_type->base_type), reference_type->mutable);
        } else if type_node->node_type == ASTNodeType::ARRAY_TYPE {
            let array_type: *const ArrayTypeNode = type_node as *const ArrayTypeNode;
            let _type: *const QualifiedType = this.CompileType(array_type->element_type);

            if array_type->size == null {
                ret this.type_manager.Pointer(_type, _type->IsMutable());
            } else {
                let size: QualifiedValue = this.CompileExpression(array_type->size, false);

                if size.Null() {
                    ret null;
                }

                if LLVMGetTypeKind(size.Type().Value()) != LLVMTypeKind::LLVMIntegerTypeKind || LLVMGetIntTypeWidth(size.Type().Value()) != 64u32 || size.Type().IsSigned() {
                    Logger::Log("Array size must be of type 'u64'.", type_node, LogSeverity::Error);
                    ret null;
                }

                ret this.type_manager.Array(_type, LLVMConstIntGetZExtValue(size.Value()), _type->IsMutable());
            }
        } else if type_node->node_type == ASTNodeType::FUNCTION_TYPE {
            let function_type: *const FunctionTypeNode = type_node as *const FunctionTypeNode;
            let (mut params: Vector<*const QualifiedType>, mut param_types: Vector<LLVMTypeRef>);
            let mut return_type: *const QualifiedType = this.CompileType(function_type->return_type);

            if LLVMGetTypeKind(return_type->Value()) == LLVMTypeKind::LLVMStructTypeKind && !return_type->IsEnum() {
                let processed_type: &mut QualifiedType = this.ProcessType(return_type);

                if LLVMGetTypeKind(processed_type.Value()) != LLVMTypeKind::LLVMPointerTypeKind {
                    return_type = processed_type;
                } else {
                    params.PushBack(processed_type);
                    param_types.PushBack(processed_type.Value());
                    return_type = this.type_manager.Primitive(LLVMVoidTypeInContext(this.context), false);
                    processed_type.sret = return_type;
                }
            }

            let mut i: u64 = 0u64;

            while i < function_type->parameters.Size() {
                let param: *const ParameterNode = function_type->parameters[i];
                let real_type: &QualifiedType = this.CompileType(param->param_type);
                let processed_type: &mut QualifiedType = real_type.IsEnum() ? real_type : this.ProcessType(real_type);
                param_types.PushBack(processed_type.Value());
                params.PushBack(processed_type);

                if real_type != processed_type {
                    processed_type.byval = real_type;
                } i += 1u64;
            }

            ret this.type_manager.Pointer(this.type_manager.Function(LLVMFunctionType(return_type->Value(), param_types.Data(), param_types.Size() as u32, function_type->var_arg ? 1i32 : 0i32), params, return_type), false);
        } else {
            Logger::Log("Unknown type '" + type_node->node_type.ToString() + "'.", type_node, LogSeverity::Error);
            ret null;
        }
    }
}