Move module heading to the top

1 files changed, 83 insertions, 83 deletions

diff --git a/boot/name_analysis.cc b/boot/name_analysis.cc
index 18aaca2..5d5bd34 100644
--- a/boot/name_analysis.cc
+++ b/boot/name_analysis.cc
@@ -195,7 +195,7 @@ namespace elna::boot
                         if (is_enum || is_record)
                         {
                             std::string message = is_enum ? "Enumeration" : "Record";
-                            if (auto alias = this->composite.get<alias_type>())
+                            if (const auto alias = this->composite.get<alias_type>())
                             {
                                 message += " '" + alias->name + "'";
                             }
@@ -220,7 +220,7 @@ namespace elna::boot
                 const std::string kind = is_enum ? "member" : "field";
                 std::string message = is_enum ? "Enumeration" : "Record";
 
-                if (auto alias = this->composite.get<alias_type>())
+                if (const auto alias = this->composite.get<alias_type>())
                 {
                     message += " '" + alias->name + "'";
                 }
@@ -267,7 +267,7 @@ namespace elna::boot
     static void collect_field_names(const type& composite_type,
             ordered_map<field_origin>& names)
     {
-        auto record = erase_generic(composite_type).get<record_type>();
+        const std::shared_ptr<record_type> record = erase_generic(composite_type).get<record_type>();
         if (record == nullptr)
         {
             return;
@@ -276,7 +276,7 @@ namespace elna::boot
         {
             collect_field_names(record->base, names);
         }
-        for (auto& field : record->fields)
+        for (const auto& field : record->fields)
         {
             names.insert(field.first, field_origin{ .position = std::nullopt, .base_type = composite_type });
         }
@@ -435,7 +435,7 @@ namespace elna::boot
                     if (!existing->second.position.has_value()
                             && !existing->second.base_type.empty())
                     {
-                        if (auto alias = existing->second.base_type.get<alias_type>())
+                        if (const auto alias = existing->second.base_type.get<alias_type>())
                         {
                             base_name = alias->name;
                         }
@@ -471,7 +471,7 @@ namespace elna::boot
 
         if (!this->bag.enter(name, variable_symbol))
         {
-            auto original = this->bag.lookup(name);
+            const std::shared_ptr<info> original = this->bag.lookup(name);
             symbol_declaration_error::redefinition original_definition{
                 .original = original->position,
                 .file = this->redefinition_file(original)
@@ -490,7 +490,7 @@ namespace elna::boot
         }
         if (field_name == "ptr")
         {
-            auto pointer = type(std::make_shared<pointer_type>(element_type));
+            const type pointer = type(std::make_shared<pointer_type>(element_type));
             return type(std::make_shared<constant_type>(pointer));
         }
         return std::nullopt;
@@ -506,9 +506,9 @@ namespace elna::boot
         }
         const type resolved_type = resolve_underlying_type(composite_type);
 
-        if (auto range_base = get_range_base_type(resolved_type))
+        if (const auto range_base = get_range_base_type(resolved_type))
         {
-            if (auto field = lookup_pointer_like_field(field_name, range_base))
+            if (const auto field = lookup_pointer_like_field(field_name, range_base))
             {
                 return field.value();
             }
@@ -524,18 +524,18 @@ namespace elna::boot
         for (const identifier& parameter : parameters)
         {
             const type parameter_symbol = type(std::make_shared<parameter_type>(parameter.name()));
-            auto info = std::make_shared<type_info>(parameter_symbol);
+            const std::shared_ptr<type_info> info_object = std::make_shared<type_info>(parameter_symbol);
 
-            info->position.emplace(parameter.position());
-            info->file = this->module_file;
+            info_object->position.emplace(parameter.position());
+            info_object->file = this->module_file;
 
-            if (this->bag.enter(parameter.name(), info))
+            if (this->bag.enter(parameter.name(), info_object))
             {
                 result.push_back(parameter_symbol);
             }
             else
             {
-                auto original = this->bag.lookup(parameter.name());
+                const std::shared_ptr<info> original = this->bag.lookup(parameter.name());
 
                 add_error<symbol_declaration_error>(parameter.position(), parameter.name(),
                         symbol_declaration_error::redefinition{
@@ -556,7 +556,7 @@ namespace elna::boot
         // to something other than a type is left to report.
         if (this->current_type.empty())
         {
-            if (auto *named = expression.is_named();
+            if (const auto *named = expression.is_named();
                     named != nullptr && this->bag.lookup(named->name) != nullptr)
             {
                 add_error<symbol_declaration_error>(named->position(),
@@ -639,13 +639,13 @@ namespace elna::boot
         {
             type base_type;
 
-            if (auto unresolved_alias = this->bag.declared(expression->base.value().name()))
+            if (const auto unresolved_alias = this->bag.declared(expression->base.value().name()))
             {
                 base_type = type(unresolved_alias);
             }
-            else if (auto base_symbol = this->bag.lookup(expression->base.value().name()))
+            else if (const auto base_symbol = this->bag.lookup(expression->base.value().name()))
             {
-                if (auto base_type_info = base_symbol->is_type())
+                if (const auto base_type_info = base_symbol->is_type())
                 {
                     base_type = base_type_info->symbol;
                 }
@@ -708,7 +708,7 @@ namespace elna::boot
 
         for (const auto& member : expression->members)
         {
-            auto existing = seen.find(member.name());
+            const std::map<std::string, source_position>::const_iterator existing = seen.find(member.name());
             if (existing != seen.end())
             {
                 add_error<member_error>(member.position(), member.name(), aggregate,
@@ -799,13 +799,13 @@ namespace elna::boot
 
         statement->body.symbols = this->bag.enter();
 
-        auto label_symbol = std::make_shared<label_info>(this->defer_depth);
+        const std::shared_ptr<label_info> label_symbol = std::make_shared<label_info>(this->defer_depth);
         label_symbol->position.emplace(statement->name.position());
         label_symbol->file = this->module_file;
 
         if (!this->bag.enter(label_name, label_symbol))
         {
-            auto original = this->bag.lookup(label_name);
+            const std::shared_ptr<info> original = this->bag.lookup(label_name);
             symbol_declaration_error::redefinition original_definition{
                 .original = original->position,
                 .file = this->redefinition_file(original)
@@ -829,7 +829,7 @@ namespace elna::boot
                     symbol_declaration_error::kind::undeclared_label);
             return;
         }
-        auto label_symbol = symbol->is_label();
+        const std::shared_ptr<label_info> label_symbol = symbol->is_label();
 
         if (label_symbol == nullptr)
         {
@@ -867,7 +867,7 @@ namespace elna::boot
     void resolving_visitor::visit(procedure_call *call)
     {
         call->callable().accept(this);
-        if (auto procedure = call->callable().type_decoration.get<procedure_type>())
+        if (const auto procedure = call->callable().type_decoration.get<procedure_type>())
         {
             call->type_decoration = procedure->return_type.proper_type;
         }
@@ -888,9 +888,9 @@ namespace elna::boot
 
     void resolving_visitor::visit(record_constructor_expression *expression)
     {
-        if (auto type_symbol = this->bag.lookup(expression->type_name.name()))
+        if (const auto type_symbol = this->bag.lookup(expression->type_name.name()))
         {
-            if (auto type_info = type_symbol->is_type())
+            if (const auto type_info = type_symbol->is_type())
             {
                 expression->type_decoration = expression->arguments.empty()
                     ? type_info->symbol
@@ -918,7 +918,7 @@ namespace elna::boot
 
     void resolving_visitor::visit(array_constructor_expression *expression)
     {
-        for (auto *element : expression->elements)
+        for (auto *const element : expression->elements)
         {
             element->accept(this);
         }
@@ -931,17 +931,17 @@ namespace elna::boot
     void resolving_visitor::visit(slicing_expression *expression)
     {
         expression->base().accept(this);
-        auto resolved_base = resolve_underlying_type(expression->base().type_decoration);
+        const type resolved_base = resolve_underlying_type(expression->base().type_decoration);
 
-        if (auto pointer = resolved_base.get<pointer_type>())
+        if (const auto pointer = resolved_base.get<pointer_type>())
         {
             expression->type_decoration = type(std::make_shared<slice_type>(pointer->base));
         }
-        else if (auto array = resolved_base.get<array_type>())
+        else if (const auto array = resolved_base.get<array_type>())
         {
             expression->type_decoration = type(std::make_shared<slice_type>(array->base));
         }
-        else if (auto slice = resolved_base.get<slice_type>())
+        else if (const auto slice = resolved_base.get<slice_type>())
         {
             expression->type_decoration = type(slice);
         }
@@ -1027,21 +1027,21 @@ namespace elna::boot
     {
         this->current_type = type();
 
-        if (auto unresolved_alias = this->bag.declared(expression->name))
+        if (const 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))
+        else if (const auto from_symbol_table = this->bag.lookup(expression->name))
         {
-            if (auto type_symbol = from_symbol_table->is_type())
+            if (const auto type_symbol = from_symbol_table->is_type())
             {
                 this->current_type = type_symbol->symbol;
             }
-            else if (auto variable_symbol = from_symbol_table->is_variable())
+            else if (const auto variable_symbol = from_symbol_table->is_variable())
             {
                 expression->type_decoration = variable_symbol->symbol;
             }
-            else if (auto procedure_symbol = from_symbol_table->is_procedure())
+            else if (const auto procedure_symbol = from_symbol_table->is_procedure())
             {
                 type procedure = type(std::make_shared<procedure_type>(procedure_symbol->symbol));
 
@@ -1051,7 +1051,7 @@ namespace elna::boot
                     procedure = substitute(procedure, procedure_symbol->parameters,
                             expression->argument_types);
                 }
-                expression->type_decoration = procedure;
+                std::swap(expression->type_decoration, procedure);
                 return;
             }
         }
@@ -1092,11 +1092,11 @@ namespace elna::boot
     {
         expression->base().accept(this);
         expression->index().accept(this);
-        auto resolved_base = resolve_underlying_type(expression->base().type_decoration);
+        const type resolved_base = resolve_underlying_type(expression->base().type_decoration);
 
         if (auto range_base = get_range_base_type(resolved_base))
         {
-            expression->type_decoration = range_base;
+            std::swap(expression->type_decoration, range_base);
 
             // Elements of a constant array are constant themselves since a static
             // array is a holistic type.
@@ -1113,11 +1113,11 @@ namespace elna::boot
         // Handling field access on a type (only valid for enumerations).
         if (!this->current_type.empty())
         {
-            auto resolved_base = resolve_underlying_type(this->current_type);
+            const type resolved_base = resolve_underlying_type(this->current_type);
 
-            if (auto enumeration_base = resolved_base.get<enumeration_type>())
+            if (const auto enumeration_base = resolved_base.get<enumeration_type>())
             {
-                auto member_iterator = std::ranges::find(enumeration_base->members, expression->field().name());
+                const auto member_iterator = std::ranges::find(enumeration_base->members, expression->field().name());
 
                 if (member_iterator == enumeration_base->members.cend())
                 {
@@ -1158,7 +1158,7 @@ namespace elna::boot
     {
         expression->base().accept(this);
 
-        if (auto pointer = resolve_underlying_type(expression->base().type_decoration).get<pointer_type>())
+        if (const auto pointer = resolve_underlying_type(expression->base().type_decoration).get<pointer_type>())
         {
             expression->type_decoration = pointer->base;
         }
@@ -1251,7 +1251,7 @@ namespace elna::boot
          * cycle is behind a pointer or a slice, so that the record layout
          * stays finite. All other cycles are rejected.
          */
-        if (auto link = referent.get<alias_type>())
+        if (const auto link = referent.get<alias_type>())
         {
             if (std::ranges::find(alias_path, link->name) != std::cend(alias_path))
             {
@@ -1270,38 +1270,38 @@ namespace elna::boot
             }
             return acyclic;
         }
-        else if (auto link = referent.get<constant_type>())
+        else if (const auto link = referent.get<constant_type>())
         {
             return find_alias_cycle(being_resolved, link->unqualified, alias_path, state);
         }
-        else if (auto link = referent.get<pointer_type>())
+        else if (const auto link = referent.get<pointer_type>())
         {
             walk_state guarded_state = state;
             guarded_state.guarded = true;
             return find_alias_cycle(being_resolved, link->base, alias_path, guarded_state);
         }
-        else if (auto link = referent.get<slice_type>())
+        else if (const auto link = referent.get<slice_type>())
         {
             walk_state guarded_state = state;
             guarded_state.guarded = true;
             return find_alias_cycle(being_resolved, link->base, alias_path, guarded_state);
         }
-        else if (auto link = referent.get<array_type>())
+        else if (const auto link = referent.get<array_type>())
         {
             return find_alias_cycle(being_resolved, link->base, alias_path, state);
         }
-        else if (auto link = referent.get<generic_type>())
+        else if (const auto link = referent.get<generic_type>())
         {
             return find_alias_cycle(being_resolved, link->referent, alias_path, state);
         }
-        else if (auto link = referent.get<instantiated_type>())
+        else if (const auto link = referent.get<instantiated_type>())
         {
             // Erasure is argument blind, so the arguments cannot close a cycle
             // the generic does not close on its own. This is what lets
             // polymorphic recursion terminate.
             return find_alias_cycle(being_resolved, link->generic, alias_path, state);
         }
-        else if (auto link = referent.get<procedure_type>())
+        else if (const auto link = referent.get<procedure_type>())
         {
             const std::size_t saved_path = alias_path.size();
 
@@ -1320,7 +1320,7 @@ namespace elna::boot
             }
             return true;
         }
-        else if (auto link = referent.get<record_type>())
+        else if (const auto link = referent.get<record_type>())
         {
             const std::size_t saved_path = alias_path.size();
             walk_state in_record = state;
@@ -1353,7 +1353,7 @@ namespace elna::boot
         }
         if (unit->entry_point.has_value())
         {
-            auto word8_primitive = lookup_primitive_type("Word8");
+            const type word8_primitive = lookup_primitive_type("Word8");
             const procedure_type::return_t result_return = procedure_type::return_t(word8_primitive);
             auto heading = procedure_type(result_return);
             std::shared_ptr<procedure_info> info;
@@ -1385,8 +1385,6 @@ namespace elna::boot
             info->position = unit->entry_position;
             info->file = this->module_file;
 
-            // A unit has at most one entry point and an imported program is
-            // rejected before its symbols are merged, so this cannot collide.
             this->bag.enter("", info);
         }
     }
@@ -1411,23 +1409,22 @@ namespace elna::boot
 
         // Reject the cycle and wire an empty referent: the declaration still
         // resolves and is entered, so its uses degrade silently.
-        if (auto cycle = find_alias_cycle(
-                this->bag.declared(declaration->identifier.name()), underlying))
+        if (const auto cycle = find_alias_cycle(this->bag.declared(declaration->identifier.name()), underlying))
         {
             add_error<cyclic_declaration_error>(declaration->position(), *cycle);
             underlying = type();
         }
         const std::shared_ptr<alias_type> resolved =
             this->bag.resolve(declaration->identifier.name(), underlying);
-        auto info = std::make_shared<type_info>(type(resolved));
+        const std::shared_ptr<type_info> info_object = std::make_shared<type_info>(type(resolved));
 
-        info->exported = declaration->identifier.exported();
-        info->position.emplace(declaration->position());
-        info->file = this->module_file;
+        info_object->exported = declaration->identifier.exported();
+        info_object->position.emplace(declaration->position());
+        info_object->file = this->module_file;
 
-        if (!this->bag.enter(declaration->identifier.name(), info))
+        if (!this->bag.enter(declaration->identifier.name(), info_object))
         {
-            auto original = this->bag.lookup(declaration->identifier.name());
+            const std::shared_ptr<info> original = this->bag.lookup(declaration->identifier.name());
             symbol_declaration_error::redefinition original_definition{
                 .original = original->position,
                 .file = this->redefinition_file(original)
@@ -1455,7 +1452,7 @@ namespace elna::boot
         }
         else if (!declaration->is_extern && resolve_aliases(variable_type).get<constant_type>() != nullptr)
         {
-                auto position_span = source_position(
+                const source_position position_span = source_position(
                         declaration->identifiers.front().id().position().start(),
                         declaration->identifiers.back().id().position().end());
                 add_error<declaration_format_error>(position_span,
@@ -1463,7 +1460,7 @@ namespace elna::boot
         }
         for (const auto& variable_identifier : declaration->identifiers)
         {
-            auto variable_symbol = register_variable(variable_identifier.name(),
+            const std::shared_ptr<variable_info> variable_symbol = register_variable(variable_identifier.name(),
                     variable_type, declaration->position(), declaration->is_extern);
             variable_symbol->exported = variable_identifier.exported();
             variable_symbol->alignment =
@@ -1482,18 +1479,19 @@ namespace elna::boot
         const std::vector<type> type_parameters = enter_parameters(declaration->parameters);
         auto [heading, parameter_names] =
             build_procedure(declaration->heading(), !declaration->body.has_value());
-        std::shared_ptr<procedure_info> info;
+        std::shared_ptr<procedure_info> info_object;
 
         if (declaration->body.has_value())
         {
-            info = std::make_shared<procedure_info>(heading, std::move(parameter_names), scope);
-            auto name_iterator = std::cbegin(info->names);
-            auto type_iterator = std::cbegin(info->symbol.parameters);
+            info_object = std::make_shared<procedure_info>(heading, std::move(parameter_names), scope);
+            auto name_iterator = std::cbegin(info_object->names);
+            auto type_iterator = std::cbegin(info_object->symbol.parameters);
 
-            while (name_iterator != std::cend(info->names) && type_iterator != std::cend(info->symbol.parameters))
+            while (name_iterator != std::cend(info_object->names)
+                    && type_iterator != std::cend(info_object->symbol.parameters))
             {
-                auto variable_symbol = register_variable(*name_iterator, *type_iterator,
-                        declaration->heading().position());
+                const std::shared_ptr<variable_info> variable_symbol =
+                    register_variable(*name_iterator, *type_iterator, declaration->heading().position());
 
                 ++name_iterator;
                 ++type_iterator;
@@ -1501,16 +1499,16 @@ namespace elna::boot
         }
         else
         {
-            info = std::make_shared<procedure_info>(heading, std::move(parameter_names));
+            info_object = std::make_shared<procedure_info>(heading, std::move(parameter_names));
         }
         this->bag.leave();
-        info->parameters = type_parameters;
-        info->exported = declaration->identifier.exported();
-        info->position.emplace(declaration->position());
-        info->file = this->module_file;
-        if (!this->bag.enter(declaration->identifier.name(), info))
+        info_object->parameters = type_parameters;
+        info_object->exported = declaration->identifier.exported();
+        info_object->position.emplace(declaration->position());
+        info_object->file = this->module_file;
+        if (!this->bag.enter(declaration->identifier.name(), info_object))
         {
-            auto original = this->bag.lookup(declaration->identifier.name());
+            const std::shared_ptr<info> original = this->bag.lookup(declaration->identifier.name());
             symbol_declaration_error::redefinition original_definition{
                 .original = original->position,
                 .file = this->redefinition_file(original)
@@ -1541,9 +1539,11 @@ namespace elna::boot
         {
             const std::shared_ptr<procedure_info> info = this->bag.lookup("")->is_procedure();
 
-            unit->entry_point->symbols = info->scope;
             this->bag.enter(info->scope);
-            traverse_body(this, unit->entry_point.value());
+            for (statement *body_statement : unit->entry_point.value())
+            {
+                body_statement->accept(this);
+            }
             this->bag.leave();
         }
     }
@@ -1564,7 +1564,7 @@ namespace elna::boot
             }
             else if (resolve_aliases(variable_type).get<constant_type>() != nullptr)
             {
-                    auto position_span = source_position(
+                    const source_position position_span = source_position(
                             declaration->identifiers.front().id().position().start(),
                             declaration->identifiers.back().id().position().end());
                     add_error<declaration_format_error>(position_span,
@@ -1572,7 +1572,7 @@ namespace elna::boot
             }
             for (const auto& variable_identifier : declaration->identifiers)
             {
-                auto variable_symbol = register_variable(variable_identifier.name(),
+                const std::shared_ptr<variable_info> variable_symbol = register_variable(variable_identifier.name(),
                         variable_type, declaration->position(), declaration->is_extern);
                 variable_symbol->exported = variable_identifier.exported();
                 variable_symbol->alignment =
@@ -1598,7 +1598,7 @@ namespace elna::boot
     void name_analysis_visitor::visit(for_statement *statement)
     {
         statement->range().accept(this);
-        auto resolved_range = resolve_underlying_type(statement->range().type_decoration);
+        const type resolved_range = resolve_underlying_type(statement->range().type_decoration);
         const type control_variable_base_type = get_range_base_type(resolved_range);
         const type control_variable_pointer_type = type(std::make_shared<pointer_type>(control_variable_base_type));
         const type control_variable_const_type = type(std::make_shared<constant_type>(control_variable_pointer_type));