Use the new .is_a() for literal kind checks in the evaluator

1 files changed, 29 insertions, 36 deletions

diff --git a/boot/name_analysis.cc b/boot/name_analysis.cc
index ae6810d..4127466 100644
--- a/boot/name_analysis.cc
+++ b/boot/name_analysis.cc
@@ -59,22 +59,22 @@ namespace elna::boot
 
     std::optional<std::pair<std::string, source_position>> declaration_error::note() const
     {
-        if (const auto *redef = std::get_if<redefinition>(&payload))
+        if (std::holds_alternative<redefinition>(this->payload))
         {
-            if (redef->original.has_value() && redef->original->start().available())
-            {
-                return std::make_pair("previously declared here", *redef->original);
-            }
+            return previous_declaration_note(std::get<redefinition>(this->payload).original);
+        }
+        else
+        {
+            return std::nullopt;
         }
-        return std::nullopt;
     }
 
-    name_analysis_error::name_analysis_error(const source_position position, payload_type payload)
+    const_qualifier_error::const_qualifier_error(const source_position position, payload_type payload)
         : error(position), payload(std::move(payload))
     {
     }
 
-    std::string name_analysis_error::what() const
+    std::string const_qualifier_error::what() const
     {
         return std::visit([](const auto& payload) -> std::string {
             using T = std::decay_t<decltype(payload)>;
@@ -99,23 +99,16 @@ namespace elna::boot
         }, this->payload);
     }
 
-    std::optional<std::pair<std::string, source_position>> name_analysis_error::note() const
+    std::optional<std::pair<std::string, source_position>> const_qualifier_error::note() const
     {
-        return std::visit([](const auto& payload) -> std::optional<std::pair<std::string, source_position>> {
-            using T = std::decay_t<decltype(payload)>;
-
-            if constexpr (std::is_same_v<T, not_initialized>)
-            {
-                auto position_span = source_position(payload.identifiers.front().position().start(),
-                        payload.identifiers.back().position().end());
-
-                return std::make_optional(std::make_pair(join(payload.identifiers), position_span));
-            }
-            else
-            {
-                return std::nullopt;
-            }
-        }, this->payload);
+        if (std::holds_alternative<not_initialized>(this->payload))
+        {
+            return identifier_list_note(std::get<not_initialized>(this->payload).identifiers);
+        }
+        else
+        {
+            return std::nullopt;
+        }
     }
 
     member_error::member_error(const source_position position, const std::string& name,
@@ -184,14 +177,14 @@ namespace elna::boot
 
     std::optional<std::pair<std::string, source_position>> member_error::note() const
     {
-        if (const auto *dup = std::get_if<duplicate>(&payload))
+        if (std::holds_alternative<duplicate>(this->payload))
         {
-            if (dup->original.has_value() && dup->original->start().available())
-            {
-                return std::make_pair("previously declared here", *dup->original);
-            }
+            return previous_declaration_note(std::get<duplicate>(this->payload).original);
+        }
+        else
+        {
+            return std::nullopt;
         }
-        return std::nullopt;
     }
 
     // Members of a constant aggregate are constant themselves.
@@ -317,8 +310,8 @@ namespace elna::boot
 
         if (this->current_type.get<constant_type>() != nullptr)
         {
-            add_error<name_analysis_error>(expression->position(),
-                    name_analysis_error::kind::duplicate);
+            add_error<const_qualifier_error>(expression->position(),
+                    const_qualifier_error::kind::duplicate);
         }
         this->current_type = type(std::make_shared<constant_type>(this->current_type));
     }
@@ -330,8 +323,8 @@ namespace elna::boot
 
         if (array_base.get<constant_type>() != nullptr)
         {
-            add_error<name_analysis_error>(expression->position(),
-                    name_analysis_error::kind::array_position);
+            add_error<const_qualifier_error>(expression->position(),
+                    const_qualifier_error::kind::array_position);
         }
         expression->dimensions().accept(this);
         const auto size_constant = this->constant_evaluator.evaluate_index(expression->dimensions());
@@ -580,8 +573,8 @@ namespace elna::boot
         {
                 auto position_span = source_position(declaration->identifiers.front().id().position().start(),
                         declaration->identifiers.back().id().position().end());
-                add_error<name_analysis_error>(position_span,
-                        name_analysis_error::not_initialized{ extract_identifiers(declaration->identifiers) });
+                add_error<const_qualifier_error>(position_span,
+                        const_qualifier_error::not_initialized{ extract_identifiers(declaration->identifiers) });
         }
         for (const identifier_definition& variable_identifier : declaration->identifiers)
         {