Add clang-tidy support

8 files changed, 143 insertions, 146 deletions

diff --git a/include/elna/boot/ast.h b/include/elna/boot/ast.h
index 30bc7c3..4e35f02 100644
--- a/include/elna/boot/ast.h
+++ b/include/elna/boot/ast.h
@@ -137,42 +137,42 @@ namespace elna::boot
     class empty_visitor : public parser_visitor
     {
     public:
-        [[noreturn]] virtual void visit(array_type_expression *) override;
-        [[noreturn]] virtual void visit(pointer_type_expression *) override;
-        [[noreturn]] virtual void visit(constant_type_expression *) override;
-        [[noreturn]] virtual void visit(type_declaration *) override;
-        [[noreturn]] virtual void visit(record_type_expression *) override;
-        [[noreturn]] virtual void visit(procedure_type_expression *) override;
-        [[noreturn]] virtual void visit(enumeration_type_expression *) override;
-
-        [[noreturn]] virtual void visit(variable_declaration *) override;
-        [[noreturn]] virtual void visit(procedure_declaration *) override;
-        [[noreturn]] virtual void visit(assign_statement *) override;
-        [[noreturn]] virtual void visit(if_statement *) override;
-        [[noreturn]] virtual void visit(import_declaration *) override;
-        [[noreturn]] virtual void visit(while_statement *) override;
-        [[noreturn]] virtual void visit(defer_statement *) override;
-        [[noreturn]] virtual void visit(empty_statement *) override;
-        [[noreturn]] virtual void visit(case_statement *) override;
-        [[noreturn]] virtual void visit(procedure_call *) override;
-        [[noreturn]] virtual void visit(unit *) override;
-        [[noreturn]] virtual void visit(cast_expression *) override;
-        [[noreturn]] virtual void visit(record_constructor_expression *) override;
-        [[noreturn]] virtual void visit(array_constructor_expression *) override;
-        [[noreturn]] virtual void visit(traits_expression *) override;
-        [[noreturn]] virtual void visit(binary_expression *) override;
-        [[noreturn]] virtual void visit(unary_expression *) override;
-        [[noreturn]] virtual void visit(named_expression *) override;
-        [[noreturn]] virtual void visit(array_access_expression *) override;
-        [[noreturn]] virtual void visit(field_access_expression *) override;
-        [[noreturn]] virtual void visit(dereference_expression *) override;
-        [[noreturn]] virtual void visit(literal<std::int32_t> *) override;
-        [[noreturn]] virtual void visit(literal<std::uint32_t> *) override;
-        [[noreturn]] virtual void visit(literal<double> *) override;
-        [[noreturn]] virtual void visit(literal<bool> *) override;
-        [[noreturn]] virtual void visit(literal<unsigned char> *) override;
-        [[noreturn]] virtual void visit(literal<std::nullptr_t> *) override;
-        [[noreturn]] virtual void visit(literal<std::string> *) override;
+        [[noreturn]] void visit(array_type_expression *) override;
+        [[noreturn]] void visit(pointer_type_expression *) override;
+        [[noreturn]] void visit(constant_type_expression *) override;
+        [[noreturn]] void visit(type_declaration *) override;
+        [[noreturn]] void visit(record_type_expression *) override;
+        [[noreturn]] void visit(procedure_type_expression *) override;
+        [[noreturn]] void visit(enumeration_type_expression *) override;
+
+        [[noreturn]] void visit(variable_declaration *) override;
+        [[noreturn]] void visit(procedure_declaration *) override;
+        [[noreturn]] void visit(assign_statement *) override;
+        [[noreturn]] void visit(if_statement *) override;
+        [[noreturn]] void visit(import_declaration *) override;
+        [[noreturn]] void visit(while_statement *) override;
+        [[noreturn]] void visit(defer_statement *) override;
+        [[noreturn]] void visit(empty_statement *) override;
+        [[noreturn]] void visit(case_statement *) override;
+        [[noreturn]] void visit(procedure_call *) override;
+        [[noreturn]] void visit(unit *) override;
+        [[noreturn]] void visit(cast_expression *) override;
+        [[noreturn]] void visit(record_constructor_expression *) override;
+        [[noreturn]] void visit(array_constructor_expression *) override;
+        [[noreturn]] void visit(traits_expression *) override;
+        [[noreturn]] void visit(binary_expression *) override;
+        [[noreturn]] void visit(unary_expression *) override;
+        [[noreturn]] void visit(named_expression *) override;
+        [[noreturn]] void visit(array_access_expression *) override;
+        [[noreturn]] void visit(field_access_expression *) override;
+        [[noreturn]] void visit(dereference_expression *) override;
+        [[noreturn]] void visit(literal<std::int32_t> *) override;
+        [[noreturn]] void visit(literal<std::uint32_t> *) override;
+        [[noreturn]] void visit(literal<double> *) override;
+        [[noreturn]] void visit(literal<bool> *) override;
+        [[noreturn]] void visit(literal<unsigned char> *) override;
+        [[noreturn]] void visit(literal<std::nullptr_t> *) override;
+        [[noreturn]] void visit(literal<std::string> *) override;
     };
 
     /**
@@ -181,42 +181,42 @@ namespace elna::boot
     class walking_visitor : public parser_visitor
     {
     public:
-        virtual void visit(array_type_expression *) override;
-        virtual void visit(pointer_type_expression *) override;
-        virtual void visit(constant_type_expression *) override;
-        virtual void visit(type_declaration *) override;
-        virtual void visit(record_type_expression *) override;
-        virtual void visit(procedure_type_expression *) override;
-        virtual void visit(enumeration_type_expression *) override;
-
-        virtual void visit(variable_declaration *) override;
-        virtual void visit(procedure_declaration *) override;
-        virtual void visit(assign_statement *) override;
-        virtual void visit(if_statement *) override;
-        virtual void visit(import_declaration *) override;
-        virtual void visit(while_statement *statement) override;
-        virtual void visit(defer_statement *statement) override;
-        virtual void visit(empty_statement *) override;
-        virtual void visit(case_statement *statement) override;
-        virtual void visit(procedure_call *call) override;
-        virtual void visit(unit *unit) override;
-        virtual void visit(cast_expression *expression) override;
-        virtual void visit(record_constructor_expression *expression) override;
-        virtual void visit(array_constructor_expression *expression) override;
-        virtual void visit(traits_expression *trait) override;
-        virtual void visit(binary_expression *expression) override;
-        virtual void visit(unary_expression *expression) override;
-        virtual void visit(named_expression *) override;
-        virtual void visit(array_access_expression *expression) override;
-        virtual void visit(field_access_expression *expression) override;
-        virtual void visit(dereference_expression *expression) override;
-        virtual void visit(literal<std::int32_t> *) override;
-        virtual void visit(literal<std::uint32_t> *) override;
-        virtual void visit(literal<double> *) override;
-        virtual void visit(literal<bool> *) override;
-        virtual void visit(literal<unsigned char> *) override;
-        virtual void visit(literal<std::nullptr_t> *) override;
-        virtual void visit(literal<std::string> *) override;
+        void visit(array_type_expression *) override;
+        void visit(pointer_type_expression *) override;
+        void visit(constant_type_expression *) override;
+        void visit(type_declaration *) override;
+        void visit(record_type_expression *) override;
+        void visit(procedure_type_expression *) override;
+        void visit(enumeration_type_expression *) override;
+
+        void visit(variable_declaration *) override;
+        void visit(procedure_declaration *) override;
+        void visit(assign_statement *) override;
+        void visit(if_statement *) override;
+        void visit(import_declaration *) override;
+        void visit(while_statement *statement) override;
+        void visit(defer_statement *statement) override;
+        void visit(empty_statement *) override;
+        void visit(case_statement *statement) override;
+        void visit(procedure_call *call) override;
+        void visit(unit *unit) override;
+        void visit(cast_expression *expression) override;
+        void visit(record_constructor_expression *expression) override;
+        void visit(array_constructor_expression *expression) override;
+        void visit(traits_expression *trait) override;
+        void visit(binary_expression *expression) override;
+        void visit(unary_expression *expression) override;
+        void visit(named_expression *) override;
+        void visit(array_access_expression *expression) override;
+        void visit(field_access_expression *expression) override;
+        void visit(dereference_expression *expression) override;
+        void visit(literal<std::int32_t> *) override;
+        void visit(literal<std::uint32_t> *) override;
+        void visit(literal<double> *) override;
+        void visit(literal<bool> *) override;
+        void visit(literal<unsigned char> *) override;
+        void visit(literal<std::nullptr_t> *) override;
+        void visit(literal<std::string> *) override;
     };
 
     /**
@@ -397,7 +397,7 @@ namespace elna::boot
         void accept(parser_visitor *visitor) override;
         array_constructor_expression *is_array_constructor() override;
 
-        virtual ~array_constructor_expression() override;
+        ~array_constructor_expression() override;
     };
 
     /**
@@ -462,7 +462,7 @@ namespace elna::boot
 
         procedure_type_expression(const source_position position,
                 std::vector<field_declaration>&& parameters, return_t return_type = return_t());
-        ~procedure_type_expression();
+        ~procedure_type_expression() override;
 
         void accept(parser_visitor *visitor) override;
         procedure_type_expression *is_procedure() override;
@@ -503,7 +503,7 @@ namespace elna::boot
 
         procedure_type_expression& heading();
 
-        virtual ~procedure_declaration() override;
+        ~procedure_declaration() override;
     };
 
     /**
@@ -515,7 +515,7 @@ namespace elna::boot
 
     public:
         type_declaration(const source_position position, identifier_definition identifier,
-                type_expression *expression);
+                type_expression *underlying_type);
         ~type_declaration() override;
 
         void accept(parser_visitor *visitor) override;
@@ -539,7 +539,7 @@ namespace elna::boot
         type_expression& target();
         expression& value();
 
-        virtual ~cast_expression() override;
+        ~cast_expression() override;
     };
 
     class traits_expression : public expression
@@ -551,7 +551,7 @@ namespace elna::boot
 
         traits_expression(const source_position position, identifier&& name,
                 std::vector<type_expression *>&& arguments);
-        ~traits_expression();
+        ~traits_expression() override;
 
         void accept(parser_visitor *visitor) override;
         traits_expression *is_traits() override;
@@ -603,8 +603,8 @@ namespace elna::boot
         virtual dereference_expression *is_dereference();
 
         designator_expression *is_designator() override;
-        void accept(parser_visitor *visitor);
-        ~designator_expression() = 0;
+        void accept(parser_visitor *visitor) override;
+        ~designator_expression() override = 0;
     };
 
     /**
@@ -684,11 +684,11 @@ namespace elna::boot
         procedure_call(const source_position position, designator_expression *callable,
                 std::vector<expression *>&& arguments);
         void accept(parser_visitor *visitor) override;
-        virtual procedure_call *is_call_expression() override;
+        procedure_call *is_call_expression() override;
 
         designator_expression& callable();
 
-        virtual ~procedure_call() override;
+        ~procedure_call() override;
     };
 
     class assign_statement : public statement
@@ -709,7 +709,7 @@ namespace elna::boot
         designator_expression& lvalue();
         expression& rvalue();
 
-        virtual ~assign_statement() override;
+        ~assign_statement() override;
     };
 
     /**
@@ -730,7 +730,7 @@ namespace elna::boot
 
         conditional_statements& branch();
 
-        virtual ~if_statement() override;
+        ~if_statement() override;
     };
 
     /**
@@ -761,7 +761,7 @@ namespace elna::boot
 
         conditional_statements& branch();
 
-        virtual ~while_statement() override;
+        ~while_statement() override;
     };
 
     class unit : public node, public procedure_body
@@ -779,9 +779,9 @@ namespace elna::boot
                 std::vector<procedure_declaration *>&& procedures,
                 std::vector<statement *>&& entry_point);
         bool has_body() const;
-        virtual void accept(parser_visitor *visitor) override;
+        void accept(parser_visitor *visitor) override;
 
-        virtual ~unit() override;
+        ~unit() override;
     };
 
     template<typename T>
@@ -809,7 +809,7 @@ namespace elna::boot
         defer_statement(const source_position position, std::vector<statement *>&& statements);
         void accept(parser_visitor *visitor) override;
 
-        virtual ~defer_statement() override;
+        ~defer_statement() override;
     };
 
     class empty_statement : public statement
@@ -836,7 +836,7 @@ namespace elna::boot
         expression& rhs();
         binary_operator operation() const;
 
-        virtual ~binary_expression() override;
+        ~binary_expression() override;
     };
 
     class unary_expression : public expression
@@ -854,7 +854,7 @@ namespace elna::boot
         expression& operand();
         unary_operator operation() const;
 
-        virtual ~unary_expression() override;
+        ~unary_expression() override;
     };
 
     const char *print_binary_operator(const binary_operator operation);
diff --git a/include/elna/boot/dependency.h b/include/elna/boot/dependency.h
index 829b669..24ded26 100644
--- a/include/elna/boot/dependency.h
+++ b/include/elna/boot/dependency.h
@@ -39,7 +39,7 @@ namespace elna::boot
 
     dependency read_source(std::istream& entry_point);
     std::filesystem::path build_path(const std::vector<std::string>& segments);
-    error_list analyze_semantics(std::unique_ptr<unit>& tree, symbol_bag bag,
+    error_list analyze_semantics(std::unique_ptr<unit>& tree, const symbol_bag& bag,
             const target_info& target);
 
     template<typename T>
@@ -51,8 +51,8 @@ namespace elna::boot
         const std::shared_ptr<symbol_table> globals;
         T custom;
 
-        using iterator = typename std::unordered_map<std::filesystem::path, symbol_bag>::iterator;
-        using const_iterator = typename std::unordered_map<std::filesystem::path, symbol_bag>::const_iterator;
+        using iterator = std::unordered_map<std::filesystem::path, symbol_bag>::iterator;
+        using const_iterator = std::unordered_map<std::filesystem::path, symbol_bag>::const_iterator;
 
         explicit dependency_state(T custom)
             : globals(builtin_symbol_table()), custom(custom)
@@ -64,7 +64,7 @@ namespace elna::boot
             return cache.find(key);
         }
 
-        void insert(const std::filesystem::path& key, symbol_bag value)
+        void insert(const std::filesystem::path& key, const symbol_bag& value)
         {
             cache.insert({ key, value });
         }
diff --git a/include/elna/boot/driver.h b/include/elna/boot/driver.h
index 8f93dbd..ef5be81 100644
--- a/include/elna/boot/driver.h
+++ b/include/elna/boot/driver.h
@@ -32,7 +32,7 @@ namespace elna::boot
     public:
         syntax_error(const std::string& message, const yy::location& location);
 
-        virtual std::string what() const override;
+        std::string what() const override;
     };
 
     class driver : public error_container
diff --git a/include/elna/boot/evaluator.h b/include/elna/boot/evaluator.h
index 6e82777..f1a5437 100644
--- a/include/elna/boot/evaluator.h
+++ b/include/elna/boot/evaluator.h
@@ -75,7 +75,7 @@ namespace elna::boot
         const target_info& target;
         const std::map<std::string, expression*>& evaluated_initializers;
 
-        std::optional<constant_value> evaluate_literal(literal_expression& subject);
+        static std::optional<constant_value> evaluate_literal(literal_expression& subject);
         std::optional<constant_value> evaluate_named(named_expression& subject);
         std::optional<constant_value> evaluate_unary(unary_expression& subject);
         std::optional<constant_value> evaluate_binary(binary_expression& subject);
diff --git a/include/elna/boot/name_analysis.h b/include/elna/boot/name_analysis.h
index 40bdf16..6f40bec 100644
--- a/include/elna/boot/name_analysis.h
+++ b/include/elna/boot/name_analysis.h
@@ -113,8 +113,8 @@ namespace elna::boot
         std::pair<procedure_type, std::vector<std::string>> build_procedure(
                 procedure_type_expression& expression);
         std::vector<type_field> build_composite_type(const std::vector<field_declaration>& fields,
-                std::map<std::string, field_origin>& known_names,
-                type aggregate);
+                std::map<std::string, field_origin>& field_names,
+                const type& aggregate);
         std::shared_ptr<variable_info> register_variable(const std::string& name,
                 const bool is_extern, const source_position position);
 
diff --git a/include/elna/boot/result.h b/include/elna/boot/result.h
index 953f701..328e44e 100644
--- a/include/elna/boot/result.h
+++ b/include/elna/boot/result.h
@@ -22,6 +22,7 @@ along with GCC; see the file COPYING3.  If not see
 #include <deque>
 #include <memory>
 #include <optional>
+#include <utility>
 #include <variant>
 
 namespace elna::boot
@@ -42,8 +43,7 @@ namespace elna::boot
 
         bool available() const;
 
-        bool operator==(const location& that) const;
-        bool operator!=(const location& that) const;
+        auto operator<=>(const location&) const = default;
 
     private:
         std::size_t m_line{ 0 };
@@ -80,6 +80,7 @@ namespace elna::boot
         error(const source_position position);
 
     public:
+        virtual ~error() = default;
         /// Error position.
         const source_position position;
 
@@ -98,7 +99,7 @@ namespace elna::boot
         }
     };
 
-    using error_list = typename std::deque<std::unique_ptr<error>>;
+    using error_list = std::deque<std::unique_ptr<error>>;
 
     class error_container
     {
@@ -111,7 +112,7 @@ namespace elna::boot
         error_list& errors();
 
         template<typename T, typename... Args>
-        void add_error(Args... arguments)
+        void add_error(Args&&... arguments)
         {
             auto new_error = std::make_unique<T>(arguments...);
             m_errors.emplace_back(std::move(new_error));
@@ -129,7 +130,7 @@ namespace elna::boot
         return_declaration() = default;
 
         explicit return_declaration(T type)
-            : proper_type(type)
+            : proper_type(std::move(type))
         {
         }
 
@@ -138,15 +139,7 @@ namespace elna::boot
         {
         }
 
-        bool operator==(const return_declaration& that) const
-        {
-            return this->proper_type == that.proper_type && this->no_return == that.no_return;
-        }
-
-        bool operator!=(const return_declaration& that) const
-        {
-            return !(*this == that);
-        }
+        auto operator<=>(const return_declaration&) const = default;
 
         T proper_type{};
         bool no_return{ false };
@@ -159,11 +152,9 @@ namespace elna::boot
         const std::string& name() const;
         const source_position& position() const;
 
-        bool operator==(const identifier& that) const;
-        bool operator!=(const identifier& that) const;
-
-        bool operator==(const std::string& that) const;
-        bool operator!=(const std::string& that) const;
+        std::strong_ordering operator<=>(const identifier& that) const;
+        bool operator==(std::string_view that) const;
+        bool operator!=(std::string_view that) const;
 
     private:
         std::string m_name;
diff --git a/include/elna/boot/symbol.h b/include/elna/boot/symbol.h
index 194c1cd..9505e5a 100644
--- a/include/elna/boot/symbol.h
+++ b/include/elna/boot/symbol.h
@@ -22,6 +22,7 @@ along with GCC; see the file COPYING3.  If not see
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <utility>
 #include <variant>
 #include <vector>
 
@@ -29,14 +30,14 @@ along with GCC; see the file COPYING3.  If not see
 
 namespace elna::boot
 {
-    class alias_type;
-    class primitive_type;
-    class record_type;
-    class pointer_type;
-    class constant_type;
-    class array_type;
-    class procedure_type;
-    class enumeration_type;
+    struct alias_type;
+    struct primitive_type;
+    struct record_type;
+    struct pointer_type;
+    struct constant_type;
+    struct array_type;
+    struct procedure_type;
+    struct enumeration_type;
 
     class type
     {
@@ -167,12 +168,12 @@ namespace elna::boot
     class symbol_map
     {
     public:
-        using symbol_ptr = typename std::enable_if<
-            std::is_convertible<U, T>::value || std::is_assignable<T, U>::value,
+        using symbol_ptr = std::enable_if_t<
+            std::is_convertible_v<U, T> || std::is_assignable_v<T, U>,
             T
-        >::type;
-        using iterator = typename std::unordered_map<std::string, symbol_ptr>::iterator;
-        using const_iterator = typename std::unordered_map<std::string, symbol_ptr>::const_iterator;
+        >;
+        using iterator = std::unordered_map<std::string, symbol_ptr>::iterator;
+        using const_iterator = std::unordered_map<std::string, symbol_ptr>::const_iterator;
 
     private:
         std::unordered_map<std::string, symbol_ptr> entries;
@@ -185,7 +186,7 @@ namespace elna::boot
          * \param scope Outer scope.
          */
         explicit symbol_map(std::shared_ptr<symbol_map> scope = nullptr)
-            : outer_scope(scope)
+            : outer_scope(std::move(scope))
         {
         }
 
@@ -258,7 +259,7 @@ namespace elna::boot
          *
          * \return Whether the insertion took place.
          */
-        bool enter(const std::string& name, symbol_ptr entry)
+        bool enter(const std::string& name, const symbol_ptr& entry)
         {
             return lookup(name) == nothing && entries.insert({ name, entry }).second;
         }
@@ -282,7 +283,7 @@ namespace elna::boot
     public:
         const type symbol;
 
-        explicit type_info(const type symbol);
+        explicit type_info(const type& symbol);
         std::shared_ptr<type_info> is_type() override;
     };
 
@@ -308,7 +309,7 @@ namespace elna::boot
          * \param names Parameter names.
          * \param scope Local definition (is `nullptr` for extern symbols).
          */
-        procedure_info(const procedure_type symbol, const std::vector<std::string> names,
+        procedure_info(const procedure_type& symbol, const std::vector<std::string>& names,
                 std::shared_ptr<symbol_table> scope = nullptr);
 
         std::shared_ptr<procedure_info> is_procedure() override;
@@ -337,7 +338,7 @@ namespace elna::boot
          * \param symbol Variable type.
          * \param is_extern Whether this is an extern symbol.
          */
-        variable_info(const type symbol, bool is_extern);
+        variable_info(const type& symbol, bool is_extern);
 
         std::shared_ptr<variable_info> is_variable() override;
     };
@@ -363,7 +364,7 @@ namespace elna::boot
          * \param unresolved Forward declarations collected in the previous step.
          * \param global_table Global symbols.
          */
-        symbol_bag(forward_table&& unresolved, std::shared_ptr<symbol_table> global_table);
+        symbol_bag(forward_table&& unresolved, const std::shared_ptr<symbol_table>& global_table);
 
         /**
          * Looks up a symbol in the current and imported modules.
@@ -382,7 +383,7 @@ namespace elna::boot
          *
          * \return Whether the insertion took place.
          */
-        bool enter(const std::string& name, std::shared_ptr<info> entry);
+        bool enter(const std::string& name, const std::shared_ptr<info>& entry);
 
         /**
          * Enters a new scope.
@@ -454,7 +455,7 @@ namespace elna::boot
     /**
      * \overload
      */
-    type resolve_underlying_type(std::shared_ptr<alias_type> alias);
+    type resolve_underlying_type(const std::shared_ptr<alias_type>& alias);
 
     /**
      * Resolves an alias chain until the underlying type or a qualified type is
diff --git a/include/elna/boot/type_check.h b/include/elna/boot/type_check.h
index 8c7dd80..51aa04d 100644
--- a/include/elna/boot/type_check.h
+++ b/include/elna/boot/type_check.h
@@ -182,11 +182,11 @@ namespace elna::boot
         type actual;
         unary_operator op;
 
-        static char unary_operator_symbol(unary_operator op);
+        static char unary_operator_symbol(unary_operator operation);
 
     public:
         unary_operation_error(const source_position position, type actual,
-                unary_operator op);
+                unary_operator operation);
 
         std::string what() const override;
     };
@@ -200,7 +200,12 @@ namespace elna::boot
      */
     struct assign_check
     {
-        enum class verdict { pass, accept, reject };
+        enum class verdict
+        {
+            pass,
+            accept,
+            reject
+        };
 
         struct context
         {
@@ -211,10 +216,10 @@ namespace elna::boot
         };
         context ctx;
 
-        verdict guard_const_laundering();
-        verdict check_exact_match();
-        verdict check_pointer_hatch();
-        verdict check_pointer_conversion();
+        verdict guard_const_laundering() const;
+        verdict check_exact_match() const;
+        verdict check_pointer_hatch() const;
+        verdict check_pointer_conversion() const;
 
         bool run();
     };
@@ -238,7 +243,7 @@ namespace elna::boot
          * of type assignee.
          */
         static bool is_assignable_from(const type& assignee, const type& assignment);
-        static bool check_unresolved_symbol(std::shared_ptr<alias_type> alias,
+        static bool check_unresolved_symbol(const std::shared_ptr<alias_type>& alias,
                 std::vector<std::string>& path);
 
     public: