From 491e62664394a8689a3f8904fbe8dbc3dea05524 Mon Sep 17 00:00:00 2001 From: Eugen Wissner Date: Sun, 30 Aug 2026 02:08:45 +0200 Subject: Fix ICEs with recursive type declarations --- boot/type_check.cc | 141 ++++++++++++++++++----------------------------------- 1 file changed, 47 insertions(+), 94 deletions(-) (limited to 'boot/type_check.cc') diff --git a/boot/type_check.cc b/boot/type_check.cc index ad27337..8f7a30f 100644 --- a/boot/type_check.cc +++ b/boot/type_check.cc @@ -18,7 +18,6 @@ along with GCC; see the file COPYING3. If not see #include "elna/boot/type_check.h" #include "elna/boot/evaluator.h" -#include #include namespace elna::boot @@ -222,25 +221,6 @@ namespace elna::boot } } - cyclic_declaration_error::cyclic_declaration_error(const source_position position, - const std::vector& cycle) - : diagnostic(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; - } - argument_count_error::argument_count_error(const source_position position, kind kind, std::string applicand, std::size_t expected, std::size_t actual) : diagnostic(position), m_kind(kind), applicand(std::move(applicand)), expected(expected), actual(actual) @@ -301,7 +281,9 @@ namespace elna::boot /* * Finds the first opaque type in a value position, following aliases, - * qualifiers, arrays, slices, records and procedures but not pointers. + * qualifiers, arrays, records and procedures but not pointers or slices. + * Pointers and slices don't store their base type by value, so an opaque + * behind them is only reachable as a transient value. */ static std::optional find_opaque_type(const type& checked) { @@ -326,10 +308,6 @@ namespace elna::boot { return find_opaque_type(array->base); } - else if (auto slice = referent.get()) - { - return find_opaque_type(slice->base); - } else if (auto procedure = referent.get()) { for (const type& parameter : procedure->parameters) @@ -387,22 +365,6 @@ namespace elna::boot || (resolved_left.get() && resolved_right.get()); } - bool type_analysis_visitor::check_unresolved_symbol(const std::shared_ptr& alias, - std::vector& alias_path) - { - if (std::ranges::find(alias_path, alias->name) != std::cend(alias_path)) - { - return false; - } - alias_path.push_back(alias->name); - - if (auto another_alias = alias->referent.get()) - { - return check_unresolved_symbol(another_alias, alias_path); - } - return true; - } - void type_analysis_visitor::visit_and_validate_condition(expression& condition) { condition.accept(this); @@ -797,78 +759,69 @@ namespace elna::boot void type_analysis_visitor::visit(type_declaration *declaration) { - std::vector alias_path; + walking_visitor::visit(declaration); auto unresolved_type = this->bag.lookup(declaration->identifier.name())->is_type()->symbol.get(); + const type referent = resolve_aliases(unresolved_type->referent); - if (!check_unresolved_symbol(unresolved_type, alias_path)) - { - add_error(declaration->position(), alias_path); - } - else + if (auto record = referent.get()) { - walking_visitor::visit(declaration); - const type referent = resolve_aliases(unresolved_type->referent); - - if (auto record = referent.get()) + for (const auto& [field_name, field_type] : record->fields) { - for (const auto& [field_name, field_type] : record->fields) + if (auto opaque = find_opaque_type(field_type)) { - if (auto opaque = find_opaque_type(field_type)) - { - add_error(declaration->position(), - opaque.value(), type_requirement_error::kind::opaque_field); - } - else if (has_zero_size(field_type, this->target)) - { - add_error(declaration->position(), - field_type, type_requirement_error::kind::zero_sized); - } + add_error(declaration->position(), + opaque.value(), type_requirement_error::kind::opaque_field); } - } - else if (auto array = referent.get()) - { - if (auto opaque = find_opaque_type(array->base)) + else if (has_zero_size(field_type, this->target)) { add_error(declaration->position(), - opaque.value(), type_requirement_error::kind::opaque_element); + field_type, type_requirement_error::kind::zero_sized); } } - else if (auto slice = referent.get()) + } + else if (auto array = referent.get()) + { + if (auto opaque = find_opaque_type(array->base)) + { + add_error(declaration->position(), + opaque.value(), type_requirement_error::kind::opaque_element); + } + } + else if (auto slice = referent.get()) + { + if (auto opaque = find_opaque_type(slice->base)) { - if (auto opaque = find_opaque_type(slice->base)) + add_error(declaration->position(), + opaque.value(), type_requirement_error::kind::opaque_element); + } + } + else if (auto procedure = referent.get()) + { + for (const type& parameter : procedure->parameters) + { + if (auto opaque = find_opaque_type(parameter)) + { + add_error(declaration->position(), + opaque.value(), type_requirement_error::kind::opaque_parameter); + } + else if (has_zero_size(parameter, this->target)) { add_error(declaration->position(), - opaque.value(), type_requirement_error::kind::opaque_element); + parameter, type_requirement_error::kind::zero_sized); } } - else if (auto procedure = referent.get()) + if (!procedure->return_type.proper_type.empty()) { - for (const type& parameter : procedure->parameters) + if (auto opaque = find_opaque_type(procedure->return_type.proper_type)) { - if (auto opaque = find_opaque_type(parameter)) - { - add_error(declaration->position(), - opaque.value(), type_requirement_error::kind::opaque_parameter); - } - else if (has_zero_size(parameter, this->target)) - { - add_error(declaration->position(), - parameter, type_requirement_error::kind::zero_sized); - } + add_error(declaration->position(), + opaque.value(), type_requirement_error::kind::opaque_return); } - if (!procedure->return_type.proper_type.empty()) + else if (has_zero_size(procedure->return_type.proper_type, this->target)) { - if (auto opaque = find_opaque_type(procedure->return_type.proper_type)) - { - add_error(declaration->position(), - opaque.value(), type_requirement_error::kind::opaque_return); - } - else if (has_zero_size(procedure->return_type.proper_type, this->target)) - { - add_error(declaration->position(), - procedure->return_type.proper_type, - type_requirement_error::kind::zero_sized); - } + add_error(declaration->position(), + procedure->return_type.proper_type, + type_requirement_error::kind::zero_sized); } } } -- cgit v1.2.3