Add clang-tidy support

1 files changed, 30 insertions, 27 deletions

diff --git a/boot/name_analysis.cc b/boot/name_analysis.cc
index b13c043..22b7814 100644
--- a/boot/name_analysis.cc
+++ b/boot/name_analysis.cc
@@ -18,6 +18,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "elna/boot/name_analysis.h"
 
 #include <algorithm>
+#include <utility>
 
 namespace elna::boot
 {
@@ -95,7 +96,7 @@ namespace elna::boot
     }
 
     name_analysis_visitor::name_analysis_visitor(symbol_bag bag)
-        : error_container(), bag(bag)
+        :  bag(std::move(bag))
     {
     }
 
@@ -120,10 +121,10 @@ namespace elna::boot
         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)
+        for (const auto& [parameter_names, parameters_type] : expression.parameters)
         {
             parameters_type->accept(this);
-            for (auto& parameter_name : parameter_names)
+            for (const auto& parameter_name : parameter_names)
             {
                 result_type.first.parameters.push_back(this->current_type);
                 result_type.second.push_back(parameter_name.name());
@@ -139,7 +140,7 @@ namespace elna::boot
 
     type name_analysis_visitor::lookup_field(const type& composite_type, const std::string& field_name)
     {
-        type resolved_type = resolve_underlying_type(composite_type);
+        type const resolved_type = resolve_underlying_type(composite_type);
 
         if (auto record = resolved_type.get<record_type>())
         {
@@ -225,21 +226,21 @@ namespace elna::boot
         }
         for (auto& field : record->fields)
         {
-            names.insert({ field.first, field_origin{ std::nullopt, composite_type } });
+            names.insert({ field.first, field_origin{ .declaration = std::nullopt, .base_type = composite_type } });
         }
     }
 
     std::vector<type_field> name_analysis_visitor::build_composite_type(
             const std::vector<field_declaration>& fields,
             std::map<std::string, field_origin>& field_names,
-            type aggregate)
+            const type& aggregate)
     {
         std::vector<type_field> result;
 
-        for (auto& field : fields)
+        for (const auto& field : fields)
         {
             field.second->accept(this);
-            for (auto& field_name : field.first)
+            for (const auto& field_name : field.first)
             {
                 auto existing = field_names.find(field_name.name());
                 if (existing != field_names.end())
@@ -260,8 +261,8 @@ namespace elna::boot
                 else
                 {
                     field_names.insert({ field_name.name(),
-                            field_origin{ field.second->position(), type() } });
-                    result.push_back(std::make_pair(field_name.name(), this->current_type));
+                            field_origin{ .declaration = field.second->position(), .base_type = type() } });
+                    result.emplace_back(field_name.name(), this->current_type);
                 }
             }
         }
@@ -350,7 +351,7 @@ namespace elna::boot
     {
         expression->m_element_type->accept(this);
         auto element_type = this->current_type;
-        for (auto element : expression->elements)
+        for (auto *element : expression->elements)
         {
             element->accept(this);
         }
@@ -359,7 +360,7 @@ namespace elna::boot
 
     void name_analysis_visitor::visit(procedure_type_expression *expression)
     {
-        std::shared_ptr<procedure_type> result_type =
+        std::shared_ptr<procedure_type> const result_type =
             std::make_shared<procedure_type>(std::move(build_procedure(*expression).first));
 
         this->current_type = type(result_type);
@@ -368,16 +369,17 @@ namespace elna::boot
     void name_analysis_visitor::visit(enumeration_type_expression *expression)
     {
         std::vector<std::string> member_names;
-        for (auto& member : expression->members)
+        member_names.reserve(expression->members.size());
+for (const auto& member : expression->members)
         {
             member_names.emplace_back(member.name());
         }
-        std::shared_ptr<enumeration_type> result_type = std::make_shared<enumeration_type>(
+        std::shared_ptr<enumeration_type> const result_type = std::make_shared<enumeration_type>(
                 member_names);
         std::map<std::string, source_position> seen;
-        type aggregate(result_type);
+        type const aggregate(result_type);
 
-        for (auto& member : expression->members)
+        for (const auto& member : expression->members)
         {
             auto existing = seen.find(member.name());
             if (existing != seen.end())
@@ -536,8 +538,8 @@ namespace elna::boot
 
             if (!trait->type_decoration.empty())
             {
-                type resolved = resolve_underlying_type(trait->type_decoration);
-                bool is_enum = resolved.get<enumeration_type>() != nullptr;
+                type const resolved = resolve_underlying_type(trait->type_decoration);
+                bool const is_enum = resolved.get<enumeration_type>() != nullptr;
 
                 if (!is_enum && !is_discrete_type(resolved))
                 {
@@ -560,15 +562,16 @@ namespace elna::boot
 
         switch (expression->operation())
         {
-            case binary_operator::equals:
-            case binary_operator::not_equals:
-            case binary_operator::less:
-            case binary_operator::greater:
-            case binary_operator::less_equal:
-            case binary_operator::greater_equal:
+                using enum binary_operator;
+            case equals:
+            case not_equals:
+            case less:
+            case greater:
+            case less_equal:
+            case greater_equal:
                 expression->type_decoration = lookup_primitive_type("Bool");
                 break;
-            case binary_operator::subtraction:
+            case subtraction:
                 if (expression->lhs().type_decoration.get<pointer_type>()
                         && expression->rhs().type_decoration.get<pointer_type>())
                 {
@@ -626,7 +629,7 @@ namespace elna::boot
     {
         walking_visitor::visit(expression);
         expression->type_decoration = lookup_field(expression->base().type_decoration, expression->field().name());
-        auto is_designator = expression->base().is_designator();
+        auto *is_designator = expression->base().is_designator();
 
         if (expression->type_decoration.empty() && is_designator != nullptr && is_designator->is_named() != nullptr)
         {
@@ -725,7 +728,7 @@ namespace elna::boot
     }
 
     declaration_visitor::declaration_visitor()
-        : error_container()
+         
     {
     }