Type check traits properly

4 files changed, 435 insertions, 35 deletions

diff --git a/boot/ast.cc b/boot/ast.cc
index 69d72fb..a2f108a 100644
--- a/boot/ast.cc
+++ b/boot/ast.cc
@@ -800,6 +800,15 @@ namespace elna::boot
         return *this->m_value;
     }
 
+    void field_initializer::value(expression& value)
+    {
+        if (this->m_value != &value)
+        {
+            delete this->m_value;
+            this->m_value = &value;
+        }
+    }
+
     record_constructor_expression::record_constructor_expression(const source_position position,
             identifier&& type_name,
             std::vector<field_initializer>&& field_initializers)
@@ -1255,16 +1264,34 @@ namespace elna::boot
         return this;
     }
 
-    expression& binary_expression::lhs()
+    expression& binary_expression::lhs() const
     {
         return *m_lhs;
     }
 
-    expression& binary_expression::rhs()
+    void binary_expression::lhs(expression& lhs)
+    {
+        if (this->m_lhs != &lhs)
+        {
+            delete this->m_lhs;
+            this->m_lhs = &lhs;
+        }
+    }
+
+    expression& binary_expression::rhs() const
     {
         return *m_rhs;
     }
 
+    void binary_expression::rhs(expression& rhs)
+    {
+        if (this->m_rhs != &rhs)
+        {
+            delete this->m_rhs;
+            this->m_rhs = &rhs;
+        }
+    }
+
     binary_operator binary_expression::operation() const
     {
         return m_operator;
@@ -1297,11 +1324,20 @@ namespace elna::boot
         return this;
     }
 
-    expression& unary_expression::operand()
+    expression& unary_expression::operand() const
     {
         return *m_operand;
     }
 
+    void unary_expression::operand(expression& operand)
+    {
+        if (this->m_operand != &operand)
+        {
+            delete this->m_operand;
+            this->m_operand = &operand;
+        }
+    }
+
     unary_operator unary_expression::operation() const
     {
         return this->m_operator;
@@ -1367,11 +1403,20 @@ namespace elna::boot
         return *m_target;
     }
 
-    expression& cast_expression::value()
+    expression& cast_expression::value() const
     {
         return *m_value;
     }
 
+    void cast_expression::value(expression& value)
+    {
+        if (this->m_value != &value)
+        {
+            delete this->m_value;
+            this->m_value = &value;
+        }
+    }
+
     cast_expression::~cast_expression()
     {
         delete m_target;
diff --git a/boot/dependency.cc b/boot/dependency.cc
index dc827fa..63d3952 100644
--- a/boot/dependency.cc
+++ b/boot/dependency.cc
@@ -56,7 +56,7 @@ namespace elna::boot
         return outcome;
     }
 
-    error_list analyze_semantics(std::unique_ptr<unit>& tree, const symbol_bag& bag,
+    error_list analyze_semantics(std::unique_ptr<unit>& tree, symbol_bag& bag,
             const target_info& target)
     {
         name_analysis_visitor name_analyser(bag);
@@ -73,6 +73,13 @@ namespace elna::boot
         {
             return std::move(type_analyzer.errors());
         }
+        constant_folder folder(bag, target);
+        tree->accept(&folder);
+
+        if (folder.has_errors())
+        {
+            return std::move(folder.errors());
+        }
         return error_list{};
     }
 
diff --git a/boot/evaluator.cc b/boot/evaluator.cc
index bb50bd3..6d3153e 100644
--- a/boot/evaluator.cc
+++ b/boot/evaluator.cc
@@ -19,11 +19,22 @@ along with GCC; see the file COPYING3.  If not see
 #include "elna/boot/ast.h"
 
 #include <algorithm>
+#include <cstddef>
 #include <limits>
 #include <ranges>
 
 namespace elna::boot
 {
+    non_constant_initializer_error::non_constant_initializer_error(const source_position position)
+        : error(position)
+    {
+    }
+
+    std::string non_constant_initializer_error::what() const
+    {
+        return "Variable initializers must be constant expressions";
+    }
+
     std::optional<type_properties> get_type_properties(const type& subject, const target_info& target)
     {
         auto resolved = resolve_underlying_type(subject);
@@ -127,9 +138,8 @@ namespace elna::boot
         };
     }
 
-    evaluator::evaluator(symbol_bag& bag, const target_info& target,
-            const std::map<std::string, expression*>& evaluated_initializers)
-        : bag(bag), target(target), evaluated_initializers(evaluated_initializers)
+    evaluator::evaluator(symbol_bag& bag, const target_info& target)
+        : bag(bag), target(target)
     {
     }
 
@@ -145,6 +155,18 @@ namespace elna::boot
             {
                 return evaluate_named(*named);
             }
+            if (auto *array_access = designator->is_array_access())
+            {
+                return evaluate_array_access(*array_access);
+            }
+            if (auto *field_access = designator->is_field_access())
+            {
+                return evaluate_field_access(*field_access);
+            }
+            if (auto *slicing = designator->is_slicing())
+            {
+                return evaluate_slicing(*slicing);
+            }
         }
         else if (auto *unary = subject.is_unary())
         {
@@ -240,20 +262,109 @@ namespace elna::boot
         {
             return std::nullopt;
         }
-        auto initializer = this->evaluated_initializers.find(subject.name);
+        return variable->value;
+    }
+
+    std::optional<constant_value> evaluator::evaluate_array_access(array_access_expression& subject)
+    {
+        auto base = evaluate(subject.base());
+        auto index = evaluate(subject.index());
+        if (!base.has_value() || !index.has_value())
+        {
+            return std::nullopt;
+        }
+        auto *array = std::get_if<constant_aggregate<std::vector>>(&base.value());
+        if (array == nullptr)
+        {
+            return std::nullopt;
+        }
+        std::size_t position;
+        if (auto *int_index = std::get_if<std::int32_t>(&index.value()))
+        {
+            if (*int_index < 0)
+            {
+                return std::nullopt;
+            }
+            position = static_cast<std::size_t>(*int_index);
+        }
+        else if (auto *word_index = std::get_if<std::uint32_t>(&index.value()))
+        {
+            position = *word_index;
+        }
+        else
+        {
+            return std::nullopt;
+        }
+        if (position >= (*array)->size())
+        {
+            return std::nullopt;
+        }
+        return (*array)->at(position);
+    }
+
+    std::optional<constant_value> evaluator::evaluate_field_access(field_access_expression& subject)
+    {
+        auto base = evaluate(subject.base());
+        if (!base.has_value())
+        {
+            return std::nullopt;
+        }
+        auto *record = std::get_if<constant_aggregate<ordered_map>>(&base.value());
+        if (record == nullptr)
+        {
+            return std::nullopt;
+        }
+        auto pos = (*record)->find(subject.field().name());
+        if (pos == (*record)->end())
+        {
+            return std::nullopt;
+        }
+        return pos->second;
+    }
 
-        return initializer == this->evaluated_initializers.end()
-            ? std::nullopt
-            : evaluate(*initializer->second);
+    std::optional<constant_value> evaluator::evaluate_slicing(slicing_expression& subject)
+    {
+        auto base = evaluate(subject.base());
+        auto start = evaluate(subject.start());
+        auto end = evaluate(subject.end());
+        if (!base.has_value() || !start.has_value() || !end.has_value())
+        {
+            return std::nullopt;
+        }
+        auto *array = std::get_if<constant_aggregate<std::vector>>(&base.value());
+        auto *start_idx = std::get_if<std::int32_t>(&start.value());
+        auto *end_idx = std::get_if<std::int32_t>(&end.value());
+        if (array == nullptr || start_idx == nullptr || end_idx == nullptr
+                || *start_idx < 0 || *end_idx < 0)
+        {
+            return std::nullopt;
+        }
+        auto start_pos = static_cast<std::size_t>(*start_idx);
+        auto end_pos = static_cast<std::size_t>(*end_idx);
+        if (start_pos > end_pos || end_pos > (*array)->size())
+        {
+            return std::nullopt;
+        }
+        auto slice_begin = std::next((*array)->begin(), static_cast<std::ptrdiff_t>(start_pos));
+        auto slice_end = std::next((*array)->begin(), static_cast<std::ptrdiff_t>(end_pos));
+
+        return constant_value{
+            constant_aggregate<std::vector>{ std::vector<constant_value>(slice_begin, slice_end) }
+        };
     }
 
     std::optional<constant_value> evaluator::evaluate_unary(unary_expression& subject)
     {
         if (subject.operation() == unary_operator::reference)
         {
-            // The address of a module-level entity is a compile-time
-            // constant.  The caller (type analysis) validates the context.
-            return constant_value{ std::nullptr_t{} };
+            if (auto *designator = subject.operand().is_designator())
+            {
+                if (auto *named = designator->is_named())
+                {
+                    return constant_value{ global_address{ .name = named->name } };
+                }
+            }
+            return std::nullopt;
         }
         auto operand = evaluate(subject.operand());
 
@@ -367,6 +478,19 @@ namespace elna::boot
                     return std::nullopt;
             }
         }
+        else if constexpr (std::is_same_v<T, global_address>)
+        {
+            switch (operation)
+            {
+            using enum binary_operator;
+                case equals:
+                    return constant_value{ lhs == rhs };
+                case not_equals:
+                    return constant_value{ lhs != rhs };
+                default:
+                    return std::nullopt;
+            }
+        }
         else
         {
             switch (operation)
@@ -645,4 +769,200 @@ namespace elna::boot
         }
         return std::nullopt;
     }
+
+    /**
+     * Converts a constant_value to an AST literal expression.
+     *
+     * \param value Evaluated constant to convert.
+     * \param position Source position for the new literal node.
+     * \param decoration Type decoration to apply to the literal.
+     * \return A new literal expression, or \c nullptr if \p value
+     *         is an aggregate (handled separately by the caller).
+     */
+    static expression *value_to_expression(const constant_value& value,
+            const source_position& position, const type& decoration)
+    {
+        return std::visit([&position, &decoration](auto&& value) -> expression*
+        {
+            using T = std::decay_t<decltype(value)>;
+
+            if constexpr (std::is_same_v<T, std::int32_t>)
+            {
+                auto *lit = new literal<std::int32_t>(position, value);
+                lit->type_decoration = decoration;
+                return lit;
+            }
+            else if constexpr (std::is_same_v<T, std::uint32_t>)
+            {
+                auto *lit = new literal<std::uint32_t>(position, value);
+                lit->type_decoration = decoration;
+                return lit;
+            }
+            else if constexpr (std::is_same_v<T, double>)
+            {
+                auto *lit = new literal<double>(position, value);
+                lit->type_decoration = decoration;
+                return lit;
+            }
+            else if constexpr (std::is_same_v<T, bool>)
+            {
+                auto *lit = new literal<bool>(position, value);
+                lit->type_decoration = decoration;
+                return lit;
+            }
+            else if constexpr (std::is_same_v<T, unsigned char>)
+            {
+                auto *lit = new literal<unsigned char>(position, value);
+                lit->type_decoration = decoration;
+                return lit;
+            }
+            else if constexpr (std::is_same_v<T, std::nullptr_t>
+                    || std::is_same_v<T, global_address>)
+            {
+                auto *lit = new literal<std::nullptr_t>(position, nullptr);
+                lit->type_decoration = decoration;
+                return lit;
+            }
+            else
+            {
+                return nullptr;
+            }
+        }, value);
+    }
+
+    expression *evaluator::fold(expression& original)
+    {
+        auto value = evaluate(original);
+        if (!value.has_value())
+        {
+            return &original;
+        }
+        if (expression *literal = value_to_expression(value.value(), original.position(), original.type_decoration))
+        {
+            delete &original;
+            return literal;
+        }
+        if (auto *record = original.is_record_constructor())
+        {
+            for (auto& field_init : record->field_initializers)
+            {
+                fold_aggregate_field(field_init);
+            }
+        }
+        else if (auto *array = original.is_array_constructor())
+        {
+            for (auto& element : array->elements)
+            {
+                element = fold(*element);
+            }
+        }
+        return &original;
+    }
+
+    void evaluator::fold_aggregate_field(field_initializer& field_init)
+    {
+        auto value = evaluate(field_init.value());
+        if (!value.has_value())
+        {
+            return;
+        }
+        expression *literal = value_to_expression(value.value(),
+                field_init.value().position(), field_init.value().type_decoration);
+        if (literal != nullptr)
+        {
+            field_init.value(*literal);
+            return;
+        }
+        expression *folded = fold(field_init.value());
+        if (folded != &field_init.value())
+        {
+            field_init.value(*folded);
+        }
+    }
+
+    constant_folder::constant_folder(symbol_bag& bag, const target_info& target)
+        : bag(bag), target(target), constant_evaluator(this->bag, this->target)
+    {
+    }
+
+    void constant_folder::visit(variable_declaration* declaration)
+    {
+        if (declaration->initializer == nullptr || has_errors())
+        {
+            return;
+        }
+        auto computed = this->constant_evaluator.evaluate(*declaration->initializer);
+        if (!computed)
+        {
+            add_error<non_constant_initializer_error>(declaration->initializer->position());
+            return;
+        }
+        declaration->initializer = this->constant_evaluator.fold(*declaration->initializer);
+
+        for (const auto& identifier : declaration->identifiers)
+        {
+            auto symbol = this->bag.lookup(identifier.name());
+            if (symbol == nullptr)
+            {
+                continue;
+            }
+            if (auto var = symbol->is_variable();
+                    resolve_aliases(var->symbol).get<constant_type>() != nullptr)
+            {
+                var->value = computed;
+            }
+        }
+    }
+
+    void constant_folder::visit(cast_expression *expr)
+    {
+        expr->target().accept(this);
+        expr->value().accept(this);
+        expr->value(fold_trait(expr->value()));
+    }
+
+    void constant_folder::visit(binary_expression *expr)
+    {
+        expr->lhs().accept(this);
+        expr->lhs(fold_trait(expr->lhs()));
+        expr->rhs().accept(this);
+        expr->rhs(fold_trait(expr->rhs()));
+    }
+
+    void constant_folder::visit(unary_expression *expr)
+    {
+        expr->operand().accept(this);
+        expr->operand(fold_trait(expr->operand()));
+    }
+
+    void constant_folder::visit(procedure_call *call)
+    {
+        call->callable().accept(this);
+        for (auto& argument : call->arguments)
+        {
+            argument->accept(this);
+            expression& folded = fold_trait(*argument);
+            if (&folded != argument)
+            {
+                delete argument;
+                argument = &folded;
+            }
+        }
+    }
+
+    expression& constant_folder::fold_trait(expression& expr)
+    {
+        if (auto *trait = expr.is_traits())
+        {
+            if (auto value = this->constant_evaluator.evaluate_traits(*trait))
+            {
+                if (auto *literal = value_to_expression(value.value(), trait->position(), trait->type_decoration))
+                {
+                    return *literal;
+                }
+            }
+        }
+        return expr;
+    }
+
 }
diff --git a/boot/type_check.cc b/boot/type_check.cc
index c88a7d1..2bb0ddd 100644
--- a/boot/type_check.cc
+++ b/boot/type_check.cc
@@ -22,14 +22,30 @@ along with GCC; see the file COPYING3.  If not see
 
 namespace elna::boot
 {
-    non_constant_initializer_error::non_constant_initializer_error(const source_position position)
-        : error(position)
+    trait_error::trait_error(const source_position position, const std::string& trait_name,
+            payload_type payload)
+        : error(position), trait_name(trait_name), m_payload(payload)
     {
     }
 
-    std::string non_constant_initializer_error::what() const
+    std::string trait_error::what() const
     {
-        return "Variable initializers must be constant expressions";
+        return std::visit([this](auto&& payload) -> std::string
+        {
+            using T = std::decay_t<decltype(payload)>;
+
+            if constexpr (std::is_same_v<T, argument_count>)
+            {
+                return "Trait #" + this->trait_name + " expects "
+                        + std::to_string(payload.expected) + " argument"
+                        + (payload.expected != 1 ? "s" : "") + ", got "
+                        + std::to_string(payload.actual);
+            }
+            else
+            {
+                return "The second argument to the #" + this->trait_name + " trait must be a field name";
+            }
+        }, this->m_payload);
     }
 
     type_mismatch_error::type_mismatch_error(const source_position position,
@@ -453,22 +469,6 @@ namespace elna::boot
         {
             return;
         }
-        evaluator constant_evaluator(this->bag, this->target, this->evaluated_initializers);
-        if (!constant_evaluator.evaluate(*declaration->initializer))
-        {
-            add_error<non_constant_initializer_error>(declaration->initializer->position());
-            return;
-        }
-        // Record const variable initializers so later declarations
-        // can chain through them.
-        for (const auto& identifier : declaration->identifiers)
-        {
-            if (auto var = this->bag.lookup(identifier.name())->is_variable();
-                    resolve_aliases(var->symbol).get<constant_type>() != nullptr)
-            {
-                this->evaluated_initializers[identifier.name()] = declaration->initializer;
-            }
-        }
         for (const identifier_definition& variable_identifier : declaration->identifiers)
         {
             auto variable_symbol = this->bag.lookup(variable_identifier.name())->is_variable();
@@ -864,4 +864,32 @@ namespace elna::boot
                     expression->lhs().type_decoration, expression->rhs().type_decoration, operation);
         }
     }
+
+    void type_analysis_visitor::visit(traits_expression *trait)
+    {
+        walking_visitor::visit(trait);
+
+        if (trait->name == "size" || trait->name == "alignment"
+                || trait->name == "min" || trait->name == "max")
+        {
+            if (trait->arguments.size() != 1)
+            {
+                add_error<trait_error>(trait->position(), trait->name.name(),
+                        trait_error::argument_count{ .expected = 1, .actual = trait->arguments.size() });
+            }
+        }
+        else if (trait->name == "offset")
+        {
+            if (trait->arguments.size() != 2)
+            {
+                add_error<trait_error>(trait->position(), trait->name.name(),
+                        trait_error::argument_count{ .expected = 2, .actual = trait->arguments.size() });
+            }
+            else if (trait->arguments.at(1)->is_named() == nullptr)
+            {
+                add_error<trait_error>(trait->arguments.at(1)->position(), trait->name.name(),
+                        trait_error::offset_not_field_name{});
+            }
+        }
+    }
 }