path: root/boot/semantic.cc

/* Name analysis.
   Copyright (C) 2025 Free Software Foundation, Inc.

GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include "elna/boot/semantic.h"

#include <algorithm>
#include <set>

namespace elna::boot
{
    undeclared_error::undeclared_error(const std::string& identifier, const struct position position)
        : error(position), identifier(identifier)
    {
    }

    std::string undeclared_error::what() const
    {
        return "Type '" + identifier + "' not declared";
    }

    already_declared_error::already_declared_error(const std::string& identifier, const struct position position)
        : error(position), identifier(identifier)
    {
    }

    std::string already_declared_error::what() const
    {
        return "Symbol '" + identifier + "' has been already declared";
    }

    field_duplication_error::field_duplication_error(const std::string& field_name, const struct position position)
        : error(position), field_name(field_name)
    {
    }

    std::string field_duplication_error::what() const
    {
        return "Repeated field name '" + field_name + "'";
    }

    cyclic_declaration_error::cyclic_declaration_error(const std::vector<std::string>& cycle,
            const struct position position)
        : error(position), cycle(cycle)
    {
    }

    std::string cyclic_declaration_error::what() const
    {
        auto segment = std::cbegin(this->cycle);
        std::string message = "Type declaration forms a cycle: " + *segment;

        ++segment;
        for (; segment != std::cend(this->cycle); ++segment)
        {
            message += " -> " + *segment;
        }
        return message;
    }

    return_error::return_error(const std::string& identifier, const struct position position)
        : error(position), identifier(identifier)
    {
    }

    std::string return_error::what() const
    {
        return "Procedure '" + this->identifier + "' is expected to return, but does not have a return statement";
    }

    base_type_error::base_type_error(const std::string& base, const struct position position)
        : error(position), base(base)
    {
    }

    std::string base_type_error::what() const
    {
        return "Record base type '" + this->base + "' is not a record.";
    }

    type_analysis_visitor::type_analysis_visitor(symbol_bag bag)
        : error_container(), bag(bag)
    {
    }

    void type_analysis_visitor::visit(procedure_declaration *declaration)
    {
        this->returns = false;
        walking_visitor::visit(declaration);

        if (declaration->body.has_value())
        {
            if (!this->returns && declaration->heading().return_type.proper_type != nullptr)
            {
                add_error<return_error>(declaration->identifier.name, declaration->position());
            }
        }
    }

    void type_analysis_visitor::visit(return_statement *statement)
    {
        walking_visitor::visit(statement);
        this->returns = true;
    }

    bool type_analysis_visitor::check_unresolved_symbol(std::shared_ptr<alias_type> alias,
            std::vector<std::string>& alias_path)
    {
        if (std::find(std::cbegin(alias_path), std::cend(alias_path), alias->name) != std::cend(alias_path))
        {
            return false;
        }
        alias_path.push_back(alias->name);

        if (auto another_alias = alias->reference.get<alias_type>())
        {
            return check_unresolved_symbol(another_alias, alias_path);
        }
        return true;
    }

    void type_analysis_visitor::visit(type_declaration *declaration)
    {
        std::vector<std::string> alias_path;
        auto unresolved_type = this->bag.lookup(declaration->identifier.name)->is_type()->symbol.get<alias_type>();

        if (!check_unresolved_symbol(unresolved_type, alias_path))
        {
            add_error<cyclic_declaration_error>(alias_path, declaration->position());
        }
        else
        {
            walking_visitor::visit(declaration);
        }
    }

    void type_analysis_visitor::visit(record_type_expression *expression)
    {
        if (expression->base.has_value())
        {
            type base_type = inner_aliased_type(this->bag.lookup(expression->base.value())->is_type()->symbol);
            if (base_type.get<record_type>() == nullptr)
            {
                add_error<base_type_error>(expression->base.value(), expression->position());
            }
        }
        walking_visitor::visit(expression);
    }

    name_analysis_visitor::name_analysis_visitor(symbol_bag bag)
        : error_container(), bag(bag)
    {
    }

    std::pair<procedure_type, std::vector<std::string>> name_analysis_visitor::build_procedure(
            procedure_type_expression& expression)
    {
        procedure_type::return_t result_return;

        if (expression.return_type.no_return)
        {
            result_return = procedure_type::return_t(std::monostate{});
        }
        else if (expression.return_type.proper_type != nullptr)
        {
            expression.return_type.proper_type->accept(this);
            result_return = procedure_type::return_t(this->current_type);
        }
        else
        {
            result_return = procedure_type::return_t();
        }
        std::pair<procedure_type, std::vector<std::string>> result_type{
            procedure_type(result_return), std::vector<std::string>()
        };
        for (auto& [parameter_names, parameters_type] : expression.parameters)
        {
            parameters_type->accept(this);
            for (auto& parameter_name : parameter_names)
            {
                result_type.first.parameters.push_back(this->current_type);
                result_type.second.push_back(parameter_name);
            }
        }
        return result_type;
    }

    void name_analysis_visitor::visit(type_declaration *declaration)
    {
        walking_visitor::visit(declaration);
        auto resolved = this->bag.resolve(declaration->identifier.name, this->current_type);
        auto info = std::make_shared<type_info>(type(resolved));

        info->exported = declaration->identifier.exported;
        this->bag.enter(declaration->identifier.name, info);
    }

    void name_analysis_visitor::visit(pointer_type_expression *expression)
    {
        walking_visitor::visit(expression);
        this->current_type = type(std::make_shared<pointer_type>(this->current_type));
    }

    void name_analysis_visitor::visit(array_type_expression *expression)
    {
        walking_visitor::visit(expression);
        auto result_type = std::make_shared<array_type>(this->current_type, expression->size);

        this->current_type = type(result_type);
    }

    std::vector<type_field> name_analysis_visitor::build_composite_type(const std::vector<field_declaration>& fields)
    {
        std::vector<type_field> result;
        std::set<std::string> field_names;

        for (auto& field : fields)
        {
            field.second->accept(this);
            for (auto& field_name : field.first)
            {
                if (field_names.find(field_name) != field_names.cend())
                {
                    add_error<field_duplication_error>(field_name, field.second->position());
                }
                else
                {
                    field_names.insert(field_name);
                    result.push_back(std::make_pair(field_name, this->current_type));
                }
            }
        }
        return result;
    }

    void name_analysis_visitor::visit(record_type_expression *expression)
    {
        std::shared_ptr<record_type> result_type;
        if (expression->base.has_value())
        {
            if (auto unresolved_alias = this->bag.declared(expression->base.value()))
            {
                result_type = std::make_shared<record_type>(type(unresolved_alias));
            }
            else if (auto base_symbol = this->bag.lookup(expression->base.value()))
            {
                if (auto base_type_info = base_symbol->is_type())
                {
                    result_type = std::make_shared<record_type>(base_type_info->symbol);
                }
                else
                {
                    add_error<base_type_error>(expression->base.value(), expression->position());
                    this->current_type = type();
                    return;
                }
            }
            else
            {
                add_error<undeclared_error>(expression->base.value(), expression->position());
                this->current_type = type();
                return;
            }
        }
        else
        {
            result_type = std::make_shared<record_type>();
        }
        result_type->fields = build_composite_type(expression->fields);

        this->current_type = type(result_type);
    }

    void name_analysis_visitor::visit(union_type_expression *expression)
    {
        auto result_type = std::make_shared<union_type>();

        result_type->fields = build_composite_type(expression->fields);

        this->current_type = type(result_type);
    }

    void name_analysis_visitor::visit(procedure_type_expression *expression)
    {
        std::shared_ptr<procedure_type> result_type =
            std::make_shared<procedure_type>(std::move(build_procedure(*expression).first));

        this->current_type = type(result_type);
    }

    void name_analysis_visitor::visit(enumeration_type_expression *expression)
    {
        std::shared_ptr<enumeration_type> result_type = std::make_shared<enumeration_type>(expression->members);

        this->current_type = type(result_type);
    }

    std::shared_ptr<variable_info> name_analysis_visitor::register_variable(const std::string& name,
            const bool is_extern, const struct position position)
    {
        auto variable_symbol = std::make_shared<variable_info>(this->current_type, is_extern);

        if (!this->bag.enter(name, variable_symbol))
        {
            add_error<already_declared_error>(name, position);
        }
        return variable_symbol;
    }

    void name_analysis_visitor::visit(variable_declaration *declaration)
    {
        walking_visitor::visit(declaration);

        for (const identifier_definition& variable_identifier : declaration->identifiers)
        {
            auto variable_symbol = register_variable(variable_identifier.name, declaration->is_extern,
                    declaration->position());
            variable_symbol->exported = variable_identifier.exported;
        }
    }

    void name_analysis_visitor::visit(constant_declaration *declaration)
    {
        walking_visitor::visit(declaration);
        auto constant_symbol = std::make_shared<constant_info>(this->current_literal);

        constant_symbol->exported = declaration->identifier.exported;
        this->bag.enter(declaration->identifier.name, constant_symbol);
    }

    void name_analysis_visitor::visit(procedure_declaration *declaration)
    {
        std::shared_ptr<procedure_info> info;
        auto [heading, parameter_names] = build_procedure(declaration->heading());

        if (declaration->body.has_value())
        {
            info = std::make_shared<procedure_info>(heading, std::move(parameter_names), this->bag.enter());
            auto name_iterator = std::cbegin(info->names);
            auto type_iterator = std::cbegin(heading.parameters);

            while (name_iterator != std::cend(info->names) && type_iterator != std::cend(heading.parameters))
            {
                this->current_type = *type_iterator;
                auto variable_symbol = register_variable(*name_iterator, false, declaration->heading().position());
                variable_symbol->exported = false;

                ++name_iterator;
                ++type_iterator;
            }
            for (constant_declaration *const constant : declaration->body.value().constants())
            {
                constant->accept(this);
            }
            for (variable_declaration *const variable : declaration->body.value().variables())
            {
                variable->accept(this);
            }
            for (statement *const statement : declaration->body.value().statements())
            {
                statement->accept(this);
            }
            this->bag.leave();
        }
        else
        {
            info = std::make_shared<procedure_info>(heading, std::move(parameter_names));
        }
        info->exported = declaration->identifier.exported;
        this->bag.enter(declaration->identifier.name, info);
    }

    void name_analysis_visitor::visit(procedure_call *call)
    {
        auto name_expression = call->callable().is_named();

        if (name_expression == nullptr || name_expression->name != "assert")
        {
            call->callable().accept(this);
        }
        for (expression *const argument : call->arguments)
        {
            argument->accept(this);
        }
    }

    void name_analysis_visitor::visit(unit *unit)
    {
        for (type_declaration *const type : unit->types)
        {
            type->accept(this);
        }
        for (variable_declaration *const variable : unit->variables)
        {
            variable->accept(this);
        }
        for (constant_declaration *const constant : unit->constants)
        {
            constant->accept(this);
        }
        for (procedure_declaration *const procedure : unit->procedures)
        {
            procedure->accept(this);
        }
        if (unit->entry_point.has_value())
        {
            this->bag.enter();
            auto variable_type = this->bag.lookup("Int")->is_type()->symbol;
            this->bag.enter("count", std::make_shared<variable_info>(variable_type, false));

            variable_type = this->bag.lookup("Char")->is_type()->symbol;
            variable_type = type(std::make_shared<pointer_type>(variable_type));
            variable_type = type(std::make_shared<pointer_type>(variable_type));
            this->bag.enter("parameters", std::make_shared<variable_info>(variable_type, false));

            for (statement *const statement : unit->entry_point.value())
            {
                statement->accept(this);
            }
            this->bag.leave();
        }
    }

    void name_analysis_visitor::visit(traits_expression *trait)
    {
        if (!trait->parameters.empty())
        {
            trait->parameters.front()->accept(this);
            trait->types.push_back(this->current_type);
        }
    }

    void name_analysis_visitor::visit(cast_expression *expression)
    {
        walking_visitor::visit(expression);
        expression->expression_type = this->current_type;
    }

    void name_analysis_visitor::visit(named_expression *expression)
    {
        if (auto unresolved_alias = this->bag.declared(expression->name))
        {
            this->current_type = type(unresolved_alias);
        }
        else if (auto from_symbol_table = this->bag.lookup(expression->name))
        {
            if (auto type_symbol = from_symbol_table->is_type())
            {
                this->current_type = type_symbol->symbol;
            }
        }
        else
        {
            add_error<undeclared_error>(expression->name, expression->position());
            this->current_type = type();
        }
    }

    void name_analysis_visitor::visit(literal<std::int32_t> *literal)
    {
        this->current_literal = literal->value;
    }

    void name_analysis_visitor::visit(literal<std::uint32_t> *literal)
    {
        this->current_literal = literal->value;
    }

    void name_analysis_visitor::visit(literal<double> *literal)
    {
        this->current_literal = literal->value;
    }

    void name_analysis_visitor::visit(literal<bool> *literal)
    {
        this->current_literal = literal->value;
    }

    void name_analysis_visitor::visit(literal<unsigned char> *literal)
    {
        this->current_literal = literal->value;
    }

    void name_analysis_visitor::visit(literal<std::nullptr_t> *literal)
    {
        this->current_literal = literal->value;
    }

    void name_analysis_visitor::visit(literal<std::string> *literal)
    {
        this->current_literal = literal->value;
    }

    declaration_visitor::declaration_visitor()
        : error_container()
    {
    }

    void declaration_visitor::visit(import_declaration *)
    {
    }

    void declaration_visitor::visit(unit *unit)
    {
        for (import_declaration *const _import : unit->imports)
        {
            _import->accept(this);
        }
        for (type_declaration *const type : unit->types)
        {
            type->accept(this);
        }
    }

    void declaration_visitor::visit(type_declaration *declaration)
    {
        const std::string& type_identifier = declaration->identifier.name;

        if (!this->unresolved.insert({ type_identifier, std::make_shared<alias_type>(type_identifier) }).second)
        {
            add_error<already_declared_error>(declaration->identifier.name, declaration->position());
        }
    }
}