c-repl/src/analysis.cpp

#include <iostream>
#include "include/utils.h"
#include "include/errors.h"
#include "include/analysis.h"

bool bool_castable(AnalysisResult type) {
    (void)type;
    return true;
}

void check_comparable(AnalysisResult res1, AnalysisResult res2, CodePosition pos) {
    if (holds_alternative<monostate>(res1) || holds_alternative<monostate>(res2)) {
        throw TypeError(ErrorType::TypesNotComparable, pos);
    }

    Type type1 = get<Type>(res1);
    Type type2 = get<Type>(res2);


    switch (type1.type) {
        case TypeType::Int:
        case TypeType::Double: {
            switch (type2.type) {
                case TypeType::Int:
                case TypeType::Double: {
                    return;
                }
                default:
                    throw TypeError(ErrorType::TypesNotComparable, pos);
            }
        }
        default:
            throw TypeError(ErrorType::TypesNotComparable, pos);
    }
}

Type get_cast(AnalysisResult type1, AnalysisResult type2, CodePosition pos) {
    (void)type1; (void)type2; (void)pos;
    return type_type_to_type(TypeType::Int);
}

bool is_arithmetic_type(Type type) {
    switch (type.type) {
        case TypeType::Int:
        case TypeType::Double:
            return true;
        default:
            return false;
    }
}

Type try_string_to_type(string type_name, CodePosition pos) {
    try {
        Type type = string_to_type(type_name);
        return type;
    } catch (...) {
        throw TypeError(ErrorType::UnknownType, pos, type_name);
    }
}

AnalysisResult analyze(Node &ast, Memory &memory) {
    if (holds_alternative<Token>(ast)) {
        Token token = get<Token>(ast);
        switch (token.type) {
            case TokenType::Litteral: {
                if (holds_alternative<int>(token.data)) {
                    return type_type_to_type(TypeType::Int);
                } else if (holds_alternative<double>(token.data)) {
                    return type_type_to_type(TypeType::Double);
                }
                throw exception();
                break;
            }
            case TokenType::Identifier: {
                string identifier = get<string>(token.data);
                
                if (!memory.contains(identifier))
                    throw RuntimeError(ErrorType::UnknownIdentifier, token.pos, identifier);

                return memory.get(identifier).type;
                throw exception();
                break;
            }
            case TokenType::Break:
            case TokenType::Continue:
                return {};
            default:
                throw exception();
        }
    } else {
        InnerNode node = get<InnerNode>(ast);
        switch (node.type) {
            case NodeType::Prog:
                analyze(node.children[0], memory);
                analyze(node.children[1], memory);
                return {};
            break;
            case NodeType::Epsilon:
                return {};
            break;
            case NodeType::If:
            case NodeType::IfElse: {
                if (!bool_castable(analyze(node.children[0], memory))) {
                    throw TypeError(ErrorType::TypeNotCastable, get_node_pos(node.children[0]), "bool");
                }

                analyze(node.children[1], memory);
                if (node.type == NodeType::IfElse)
                    analyze(node.children[2], memory);

                return {};
            } break;
            case NodeType::While: {
                if (!bool_castable(analyze(node.children[0], memory))) {
                    throw TypeError(ErrorType::TypeNotCastable, get_node_pos(node.children[0]), "bool");
                }
                analyze(node.children[1], memory);

                return {};
            } break;
            case NodeType::For: {
                memory.add_scope(ScopeType::For);

                analyze(node.children[0], memory);

                if (!bool_castable(analyze(node.children[1], memory))) {
                    throw TypeError(ErrorType::TypeNotCastable, get_node_pos(node.children[1]), "bool");
                }

                analyze(node.children[2], memory);
                analyze(node.children[3], memory);

                memory.remove_scope();

                return {};
            } break;
            case NodeType::Bloc: {
                memory.add_scope(ScopeType::Block);
                analyze(node.children[0], memory);
                memory.remove_scope();
                return {};
            } break;
            case NodeType::Lor:
            case NodeType::Land: {
                if (!bool_castable(analyze(node.children[0], memory))) {
                    throw TypeError(ErrorType::TypeNotCastable, get_node_pos(node.children[0]), "bool");
                }
                if (!bool_castable(analyze(node.children[1], memory))) {
                    throw TypeError(ErrorType::TypeNotCastable, get_node_pos(node.children[1]), "bool");
                }
                
                return type_type_to_type(TypeType::Int);
            } break;
            case NodeType::Neg: {
                if (!bool_castable(analyze(node.children[0], memory))) {
                    throw TypeError(ErrorType::TypeNotCastable, get_node_pos(node.children[0]), "bool");
                }

                return type_type_to_type(TypeType::Int);
            } break;
            case NodeType::Lt:
            case NodeType::Gt:
            case NodeType::Leq:
            case NodeType::Geq: {
                AnalysisResult res1 = analyze(node.children[0], memory);
                AnalysisResult res2 = analyze(node.children[1], memory);

                check_comparable(res1, res2, node.pos);
                
                return type_type_to_type(TypeType::Int);
            } break;
            case NodeType::Eq:
            case NodeType::Neq:
            case NodeType::Plus:
            case NodeType::Minus:
            case NodeType::Mult:
            case NodeType::Div: {
                AnalysisResult res1 = analyze(node.children[0], memory);
                AnalysisResult res2 = analyze(node.children[1], memory);

                return get_cast(res1, res2, node.pos);
            } break;
            case NodeType::Mod: {
                AnalysisResult e1 = analyze(node.children[0], memory);
                AnalysisResult e2 = analyze(node.children[1], memory);

                if (holds_alternative<monostate>(e1) || get<Type>(e1).type != TypeType::Int) {
                    throw TypeError(ErrorType::ExpectedIntegralType, get_node_pos(node.children[0]));
                }
                if (holds_alternative<monostate>(e2) || get<Type>(e2).type != TypeType::Int) {
                    throw TypeError(ErrorType::ExpectedIntegralType, get_node_pos(node.children[1]));
                }

                return type_type_to_type(TypeType::Int);
            } break;
            case NodeType::UnaryPlus:
            case NodeType::UnaryMinus: {
                AnalysisResult res = analyze(node.children[0], memory);
                
                if (holds_alternative<monostate>(res) || !is_arithmetic_type(get<Type>(res))) {
                    throw TypeError(ErrorType::ExpectedArithmeticType, get_node_pos(node.children[0]));
                }

                return get<Type>(res);
            } break;
            case NodeType::Declaration: {
                Token type_token = get<Token>(node.children[0]);
                string type_string = get<string>(type_token.data);

                Token token = get<Token>(node.children[1]);
                string identifier = get<string>(token.data);

                if (memory.contains_top(identifier))
                    throw RuntimeError(ErrorType::AlreadyDeclaredIdentifier, token.pos, identifier);

                Type type = try_string_to_type(type_string, type_token.pos);
                memory.declare(identifier, type, type_token.pos);
                
                return {};
            } break;
            case NodeType::AssignedDeclaration: {
                Token type_token = get<Token>(node.children[0]);
                string type_string = get<string>(type_token.data);

                Token token = get<Token>(node.children[1]);
                string identifier = get<string>(token.data);

                if (memory.contains_top(identifier))
                    throw RuntimeError(ErrorType::AlreadyDeclaredIdentifier, token.pos, identifier);

                Type type = try_string_to_type(type_string, type_token.pos);
                memory.declare(identifier, type, type_token.pos);

                get_cast(type, analyze(node.children[2], memory), get_node_pos(node));

                return type;
            } break;
            case NodeType::Assignment: {
                Token identifierTok = get<Token>(node.children[0]);
                string identifier = get<string>(identifierTok.data);
                if (!memory.contains(identifier))
                    throw RuntimeError(ErrorType::UnknownIdentifier, identifierTok.pos, identifier);
                
                Type type = memory.get(identifier).type;
                AnalysisResult res = analyze(node.children[1], memory);

                get_cast(type, res, get_node_pos(node.children[1]));

                return type;
            } break;
            case NodeType::LIncr:
            case NodeType::RIncr:
            case NodeType::LDecr:
            case NodeType::RDecr: {
                Token identifierTok = get<Token>(node.children[0]);
                string identifier = get<string>(identifierTok.data);

                if (!memory.contains(identifier))
                    throw RuntimeError(ErrorType::UnknownIdentifier, identifierTok.pos, identifier);

                return memory.get(identifier).type;
            }
            case NodeType::Comma: {
                analyze(node.children[0], memory);
                return analyze(node.children[1], memory);
            }
            case NodeType::FunctionPrototype: {
                Token return_type_token = get<Token>(node.children[0]);
                string return_type_string = get<string>(return_type_token.data);
                Type return_type = try_string_to_type(return_type_string, return_type_token.pos);

                Token token = get<Token>(node.children[1]);
                string function_name = get<string>(token.data);

                try {
                    memory.get_function_scope();
                    throw RuntimeError(ErrorType::NestedFunction, token.pos, {});
                } catch (const InternalError& _) {}

                if (memory.contains(function_name)) {
                    // Il existe une variable non fonction à ce nom
                    if (memory.get(function_name).type.type != TypeType::Function) {
                        throw RuntimeError(ErrorType::IncompatibleRedefinition, token.pos, function_name);
                    }
                }

                memory.declare(function_name, {
                    .type = TypeType::Function,
                    .data = make_fn_prototype(node)
                }, return_type_token.pos);

                return {};
            } break;
            case NodeType::FunctionDeclaration: {
                Token return_type_token = get<Token>(node.children[0]);
                string return_type_string = get<string>(return_type_token.data);
                Type return_type = try_string_to_type(return_type_string, return_type_token.pos);

                Token token = get<Token>(node.children[1]);
                string function_name = get<string>(token.data);

                // Déclarée dans une fonction
                try {
                    memory.get_function_scope();
                    throw RuntimeError(ErrorType::NestedFunction, token.pos, {});
                } catch (const InternalError& _) {}

                // Corps de la fonction déjà déclaré
                if (memory.contains(function_name) && memory.get(function_name).initialized)
                    throw RuntimeError(ErrorType::FunctionRedefinition, token.pos, function_name);

                FunctionPrototype prototype =  make_fn_prototype(node);

                if (memory.contains(function_name)) {
                    // Il existe une variable non fonction à ce nom
                    if (memory.get(function_name).type.type != TypeType::Function) {
                        throw RuntimeError(ErrorType::IncompatibleRedefinition, token.pos, function_name);
                    }
                    
                    //TODO: Vérification de la cohérence des arguments avec ceux du prototype
                }

                memory.declare(function_name, {
                    .type=TypeType::Function,
                    .data=prototype
                }, return_type_token.pos);

                memory.update(function_name, node.children[3]);

                memory.add_scope(ScopeType::Function, token.pos, &memory.get(function_name));
                for (tuple<Type, string> variable : prototype) {
                    Type vtype = get<0>(variable);
                    string vname = get<1>(variable);

                    memory.declare(vname, vtype, token.pos);
                }
                analyze(node.children[3], memory);
                memory.remove_scope();

                return {};
            } break;
            default:
                return {};
        }
    }
    throw exception();
}