Check that constants are initialized

24 files changed, 343 insertions, 197 deletions

diff --git a/boot/ast.cc b/boot/ast.cc
index 7157315..fb1e276 100644
--- a/boot/ast.cc
+++ b/boot/ast.cc
@@ -394,6 +394,7 @@ namespace elna::boot
     void walking_visitor::visit(array_type_expression *expression)
     {
         expression->base().accept(this);
+        expression->dimensions().accept(this);
     }
 
     void walking_visitor::visit(slice_type_expression *expression)
@@ -451,7 +452,7 @@ namespace elna::boot
 
     void walking_visitor::visit(array_constructor_expression *expression)
     {
-        expression->m_element_type->accept(this);
+        expression->array_type().accept(this);
         for (auto *element : expression->elements)
         {
             element->accept(this);
@@ -626,14 +627,15 @@ namespace elna::boot
     }
 
     array_type_expression::array_type_expression(const source_position position,
-            type_expression *base, const std::uint32_t size)
-        : node(position), m_base(base), size(size)
+            type_expression *base, expression *dimensions)
+        : node(position), m_base(base), m_dimensions(dimensions)
     {
     }
 
     array_type_expression::~array_type_expression()
     {
-        delete m_base;
+        delete this->m_base;
+        delete this->m_dimensions;
     }
 
     void array_type_expression::accept(parser_visitor *visitor)
@@ -646,9 +648,14 @@ namespace elna::boot
         return this;
     }
 
-    type_expression& array_type_expression::base()
+    type_expression& array_type_expression::base() const
     {
-        return *m_base;
+        return *this->m_base;
+    }
+
+    expression& array_type_expression::dimensions() const
+    {
+        return *this->m_dimensions;
     }
 
     slice_type_expression::slice_type_expression(const source_position position,
@@ -659,7 +666,7 @@ namespace elna::boot
 
     slice_type_expression::~slice_type_expression()
     {
-        delete m_base;
+        delete this->m_base;
     }
 
     void slice_type_expression::accept(parser_visitor *visitor)
@@ -818,9 +825,8 @@ namespace elna::boot
     }
 
     array_constructor_expression::array_constructor_expression(const source_position position,
-            std::uint32_t size, type_expression *element_type,
-            std::vector<expression *>&& elements)
-        : node(position), size(size), m_element_type(element_type), elements(std::move(elements))
+            array_type_expression *element_type, std::vector<expression *>&& elements)
+        : node(position), m_element_type(element_type), elements(std::move(elements))
     {
     }
 
@@ -834,9 +840,14 @@ namespace elna::boot
         return this;
     }
 
+    array_type_expression& array_constructor_expression::array_type() const
+    {
+        return *this->m_element_type;
+    }
+
     array_constructor_expression::~array_constructor_expression()
     {
-        delete m_element_type;
+        delete this->m_element_type;
         for (const expression *element : elements)
         {
             delete element;
diff --git a/boot/dependency.cc b/boot/dependency.cc
index a44b1f5..9ab5141 100644
--- a/boot/dependency.cc
+++ b/boot/dependency.cc
@@ -56,7 +56,7 @@ namespace elna::boot
     error_list analyze_semantics(std::unique_ptr<unit>& tree, symbol_bag& bag,
             const target_info& target)
     {
-        name_analysis_visitor name_analyser(bag);
+        name_analysis_visitor name_analyser(bag, target);
         tree->accept(&name_analyser);
 
         if (name_analyser.has_errors())
diff --git a/boot/evaluator.cc b/boot/evaluator.cc
index 8f414fa..407370a 100644
--- a/boot/evaluator.cc
+++ b/boot/evaluator.cc
@@ -19,13 +19,56 @@ 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_expression_error::non_constant_expression_error(const source_position position, payload_type payload)
+        : error(position), payload(std::move(payload))
+    {
+    }
+
+    std::string non_constant_expression_error::what() const
+    {
+        return std::visit([](const auto& payload) -> std::string {
+            using T = std::decay_t<decltype(payload)>;
+
+            if constexpr (std::is_same_v<T, initializer>)
+            {
+                return "Variable initializers must be constant expressions";
+            }
+            else if constexpr (std::is_same_v<T, case_label>)
+            {
+                return "Case label must be a constant expression";
+            }
+            else if constexpr (std::is_same_v<T, array_dimensions>)
+            {
+                return "Array dimensions for type '" + payload.array_type.to_string()
+                    + "' should be constant";
+            }
+        }, this->payload);
+    }
+
+    std::optional<std::pair<std::string, source_position>> non_constant_expression_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, initializer>)
+            {
+                auto position_span = source_position(payload.identifiers.front().position().start(),
+                        payload.identifiers.back().position().end());
+                return std::make_pair(join(payload.identifiers), position_span);
+            }
+            else
+            {
+                return std::nullopt;
+            }
+        }, this->payload);
+    }
+
     std::optional<type_properties> get_type_properties(const type& subject, const target_info& target)
     {
         auto resolved = resolve_underlying_type(subject);
@@ -209,6 +252,8 @@ namespace elna::boot
 
     std::optional<constant_value> evaluator::evaluate_literal(literal_expression& subject)
     {
+        // The type decoration here is trustable since the name analysis derives
+        // the decoration from literal's own value.
         type const decoration = subject.type_decoration;
 
         if (is_primitive_type(decoration, "Int") || is_primitive_type(decoration, "Word"))
@@ -283,54 +328,49 @@ namespace elna::boot
         auto resolved_base = resolve_underlying_type(type_to_check);
         if (auto enumeration = resolved_base.get<enumeration_type>())
         {
-            auto enumeration_position = std::distance(enumeration->members.begin(),
+            auto enumeration_distance = std::distance(enumeration->members.begin(),
                     std::ranges::find(enumeration->members, subject.field().name()));
+            const std::size_t enumeration_position = static_cast<std::size_t>(enumeration_distance);
 
-            return constant_value{
-                integer_literal::from(static_cast<std::size_t>(enumeration_position + 1))
-            };
+            if (enumeration_position >= enumeration->members.size())
+            {
+                return std::nullopt;
+            }
+            return constant_value{ integer_literal::from(enumeration_position + 1U) };
         }
         else if (auto base = evaluate(subject.base()))
         {
             if (auto *record = std::get_if<constant_aggregate<ordered_map>>(&base.value()))
             {
-                return (**record)[subject.field().name()];
+                auto field_iterator = (*record)->find(subject.field().name());
+
+                return field_iterator != std::cend(**record)
+                    ? std::make_optional(field_iterator->second)
+                    : std::nullopt;
+            }
+            else if (auto *vector = std::get_if<constant_aggregate<std::vector>>(&base.value());
+                    subject.field() == "length")
+            {
+                return constant_value{ integer_literal::from((*vector)->size()) };
             }
             else if (auto *string_value = std::get_if<std::string>(&base.value()); subject.field() == "length")
             {
                 return constant_value{ integer_literal::from(string_value->size()) };
             }
         }
-        else if (auto array = resolved_base.get<array_type>(); subject.field() == "length")
-        {
-            return constant_value{ integer_literal::from(array->size) };
-        }
         return std::nullopt;
     }
 
     std::optional<std::size_t> evaluator::evaluate_index(expression& subject)
     {
         auto evaluated_index = evaluate(subject);
-        if (!evaluated_index.has_value())
+        if (!evaluated_index.has_value() || !std::holds_alternative<integer_literal>(evaluated_index.value()))
         {
             return std::nullopt;
         }
-        auto index_literal = std::get<integer_literal>(evaluated_index.value());
-
-        if (index_literal.is_signed())
-        {
-            auto signed_index = index_literal.to_signed();
+        auto& index_literal = std::get<integer_literal>(evaluated_index.value());
 
-            if (!signed_index.has_value() || signed_index.value() <= 0)
-            {
-                return std::nullopt;
-            }
-            return static_cast<std::size_t>(signed_index.value());
-        }
-        else
-        {
-            return index_literal.to_unsigned();
-        }
+        return index_literal.is_negative() ? std::nullopt : index_literal.to_unsigned();
     }
 
     std::optional<constant_value> evaluator::evaluate_slicing(slicing_expression& subject)
@@ -656,14 +696,13 @@ namespace elna::boot
 
     std::optional<constant_value> evaluator::evaluate_cast(cast_expression& subject)
     {
-        if (auto value = evaluate(subject.value()))
-        {
-            return constant_value{ value.value() };
-        }
-        else
+        auto value = evaluate(subject.value());
+
+        if (!value.has_value() || subject.type_decoration.empty())
         {
             return std::nullopt;
         }
+        return constant_value{ value.value() };
     }
 
     std::optional<std::size_t> evaluator::evaluate_traits_size(const type& subject)
diff --git a/boot/name_analysis.cc b/boot/name_analysis.cc
index 3667dff..56ea399 100644
--- a/boot/name_analysis.cc
+++ b/boot/name_analysis.cc
@@ -126,7 +126,8 @@ namespace elna::boot
                     case field_on_type:
                         return "Cannot access field '" + this->name + "' on type '"
                             + this->composite.to_string() + "'";
-                        break;
+                    default:
+                        __builtin_unreachable();
                 }
             }
             else if constexpr (std::is_same_v<T, duplicate>)
@@ -163,6 +164,23 @@ namespace elna::boot
         return std::nullopt;
     }
 
+    not_initialized_error::not_initialized_error(const source_position position, std::vector<identifier> identifiers)
+        : error(position), identifiers(std::move(identifiers))
+    {
+    }
+
+    std::string not_initialized_error::what() const
+    {
+        return "All constants should be initialized";
+    }
+
+    std::optional<std::pair<std::string, source_position>> not_initialized_error::note() const
+    {
+        auto position_span = source_position(this->identifiers.front().position().start(),
+                this->identifiers.back().position().end());
+        return std::make_pair(join(this->identifiers), position_span);
+    }
+
     // Members of a constant aggregate are constant themselves.
     static type qualify_member_type(const type& element, const type& aggregate)
     {
@@ -177,8 +195,8 @@ namespace elna::boot
         }
     }
 
-    name_analysis_visitor::name_analysis_visitor(symbol_bag bag)
-        :  bag(std::move(bag))
+    name_analysis_visitor::name_analysis_visitor(symbol_bag bag, const target_info& target)
+        :  bag(std::move(bag)), constant_evaluator(this->bag, target)
     {
     }
 
@@ -294,14 +312,23 @@ namespace elna::boot
 
     void name_analysis_visitor::visit(array_type_expression *expression)
     {
-        walking_visitor::visit(expression);
+        expression->base().accept(this);
+        auto array_base = this->current_type;
 
-        if (this->current_type.get<constant_type>() != nullptr)
+        if (array_base.get<constant_type>() != nullptr)
         {
             add_error<const_qualifier_error>(expression->position(),
                     const_qualifier_error::kind::array_position);
         }
-        this->current_type = type(std::make_shared<array_type>(this->current_type, expression->size));
+        expression->dimensions().accept(this);
+        const auto size_constant = this->constant_evaluator.evaluate_index(expression->dimensions());
+
+        if (!size_constant.has_value())
+        {
+            add_error<non_constant_expression_error>(expression->position(),
+                    non_constant_expression_error::array_dimensions{ array_base });
+        }
+        this->current_type = type(std::make_shared<array_type>(array_base, size_constant.value()));
     }
 
     void name_analysis_visitor::visit(slice_type_expression *expression)
@@ -437,13 +464,12 @@ namespace elna::boot
 
     void name_analysis_visitor::visit(array_constructor_expression *expression)
     {
-        expression->m_element_type->accept(this);
-        auto element_type = this->current_type;
+        expression->array_type().accept(this);
+        expression->type_decoration = this->current_type;
         for (auto *element : expression->elements)
         {
             element->accept(this);
         }
-        expression->type_decoration = type(std::make_shared<array_type>(element_type, expression->size));
         this->current_type = type();
     }
 
@@ -523,20 +549,36 @@ namespace elna::boot
     {
         declaration->variable_type().accept(this);
         auto variable_type = this->current_type;
+        std::optional<constant_value> computed;
+
         if (declaration->initializer != nullptr)
         {
             declaration->initializer->accept(this);
             this->current_type = variable_type;
+            computed = this->constant_evaluator.evaluate(*declaration->initializer);
+
+            if (this->bag.is_global() && !computed.has_value())
+            {
+                add_error<non_constant_expression_error>(declaration->initializer->position(),
+                        non_constant_expression_error::initializer{ extract_identifiers(declaration->identifiers) });
+            }
+        }
+        else if (resolve_aliases(variable_type).get<constant_type>() != nullptr)
+        {
+                auto position_span = source_position(declaration->identifiers.front().id().position().start(),
+                        declaration->identifiers.back().id().position().end());
+                add_error<not_initialized_error>(position_span,
+                        extract_identifiers(declaration->identifiers));
         }
         for (const identifier_definition& variable_identifier : declaration->identifiers)
         {
             auto variable_symbol = register_variable(variable_identifier.name(), declaration->is_extern,
                     declaration->position());
             variable_symbol->exported = variable_identifier.exported();
+            variable_symbol->value = computed;
         }
     }
 
-
     void name_analysis_visitor::visit(procedure_declaration *declaration)
     {
         std::shared_ptr<procedure_info> info;
diff --git a/boot/parser.yy b/boot/parser.yy
index bc0cb53..a28b6cb 100644
--- a/boot/parser.yy
+++ b/boot/parser.yy
@@ -135,11 +135,11 @@ along with GCC; see the file COPYING3.  If not see
 %type <elna::boot::binary_expression *> binary_expression;
 %type <std::vector<elna::boot::expression *>> expressions actual_parameter_list;
 %type <elna::boot::designator_expression *> designator_expression;
-%type <elna::boot::procedure_call*> call_expression;
+%type <std::unique_ptr<elna::boot::procedure_call>> call_expression;
 %type <elna::boot::statement *> statement;
 %type <std::vector<elna::boot::statement *>> statements statement_part;
 %type <elna::boot::procedure_declaration *> procedure_declaration;
-%type <elna::boot::procedure_type_expression *> procedure_heading;
+%type <std::unique_ptr<elna::boot::procedure_type_expression>> procedure_heading;
 %type <elna::boot::procedure_type_expression::return_t> return_declaration;
 %type <std::vector<elna::boot::procedure_declaration *>> procedure_part;
 %type <elna::boot::type_declaration *> type_declaration;
@@ -157,6 +157,7 @@ along with GCC; see the file COPYING3.  If not see
 %type <std::vector<std::string>> import_declaration;
 %type <std::vector<elna::boot::identifier>> identifiers;
 %type <std::vector<elna::boot::import_declaration *>> import_declarations import_part;
+%type <std::unique_ptr<elna::boot::array_type_expression>> array_type_expression;
 %%
 program:
     import_part type_part variable_part procedure_part statement_part "end" "."
@@ -188,15 +189,16 @@ return_declaration:
     | ":" "!" { $$ = boot::procedure_type_expression::return_t(std::monostate{}); }
     | ":" type_expression { $$ = boot::procedure_type_expression::return_t($2); }
 procedure_heading: "(" optional_fields ")" return_declaration
-        { $$ = new boot::procedure_type_expression(boot::make_position(@$), $2, $4); }
+        { $$ = std::make_unique<boot::procedure_type_expression>(boot::make_position(@$), $2, $4); }
 procedure_declaration:
     "proc" identifier_definition procedure_heading procedure_body
         {
-            $$ = new boot::procedure_declaration(boot::make_position(@$), std::move(*$2), $3, std::move(*$4));
+            $$ = new boot::procedure_declaration(boot::make_position(@$),
+                    std::move(*$2), $3.release(), std::move(*$4));
         }
     | "proc" identifier_definition procedure_heading "extern"
         {
-            $$ = new boot::procedure_declaration(boot::make_position(@$), std::move(*$2), $3);
+            $$ = new boot::procedure_declaration(boot::make_position(@$), std::move(*$2), $3.release());
         }
 procedure_part:
     %empty {}
@@ -207,7 +209,7 @@ procedure_part:
         }
 call_expression: designator_expression actual_parameter_list
         {
-            $$ = new boot::procedure_call(boot::make_position(@$), $1, $2);
+            $$ = std::make_unique<boot::procedure_call>(boot::make_position(@$), $1, $2);
         }
 with_counter:
     "with" identifier { $$ = $2; }
@@ -254,15 +256,15 @@ simple_expression:
         {
             $$ = new boot::cast_expression(boot::make_position(@$), $5, $3);
         }
-    | call_expression { $$ = $1; }
+    | call_expression { $$ = $1.release(); }
     | "(" expression ")" { $$ = $2; }
     | identifier "{" field_initializers "}"
         {
             $$ = new boot::record_constructor_expression(boot::make_position(@$), std::move(*$1), $3);
         }
-    | "[" INTEGER "]" type_expression "{" expressions "}"
+    | array_type_expression "{" expressions "}"
         {
-            $$ = new boot::array_constructor_expression(boot::make_position(@$), $2, $4, $6);
+            $$ = new boot::array_constructor_expression(boot::make_position(@$), $1.release(), $3);
         }
 operand:
     unary_expression { $$ = $1; }
@@ -399,7 +401,7 @@ statement:
             boot::conditional_statements *then = new boot::conditional_statements($2, $4);
             $$ = new boot::if_statement(boot::make_position(@$), then, $5, $6);
         }
-    | call_expression { $$ = $1; }
+    | call_expression { $$ = $1.release(); }
     | "defer" statements "end"
         { $$ = new boot::defer_statement(boot::make_position(@$), $2); }
     | "case" expression "of" switch_cases else_statements "end"
@@ -449,11 +451,10 @@ field_initializers:
             $$.emplace($$.cbegin(), std::move(*$1));
         }
     | field_initializer { $$.push_back(std::move(*$1)); }
+array_type_expression: "[" expression "]" type_expression
+        { $$ = std::make_unique<boot::array_type_expression>(boot::make_position(@$), $4, $2); }
 type_expression:
-    "[" INTEGER "]" type_expression
-        {
-            $$ = new boot::array_type_expression(boot::make_position(@$), $4, $2);
-        }
+    array_type_expression { $$ = $1.release(); }
     | "[" "]" type_expression
         {
             $$ = new boot::slice_type_expression(boot::make_position(@$), $3);
@@ -476,7 +477,7 @@ type_expression:
         }
     | "proc" procedure_heading
         {
-            $$ = $2;
+            $$ = $2.release();
         }
     | "(" identifiers ")"
         {
diff --git a/boot/result.cc b/boot/result.cc
index c47be95..e9090de 100644
--- a/boot/result.cc
+++ b/boot/result.cc
@@ -17,6 +17,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "elna/boot/result.h"
 
+#include <algorithm>
 #include <cstring>
 #include <numeric>
 
@@ -87,6 +88,11 @@ namespace elna::boot
         return this->m_name;
     }
 
+    std::string identifier::to_string() const
+    {
+        return name();
+    }
+
     const source_position& identifier::position() const
     {
         return this->m_position;
@@ -123,6 +129,17 @@ namespace elna::boot
         return this->m_exported;
     }
 
+    std::vector<identifier> extract_identifiers(const std::vector<identifier_definition>& identifiers)
+    {
+        std::vector<identifier> result;
+        result.reserve(identifiers.size());
+
+        std::ranges::transform(identifiers, std::back_inserter(result),
+                [](const auto& identifier) { return identifier.id(); });
+
+        return result;
+    }
+
     integer_literal::integer_literal(bool is_signed, std::size_t size)
         : m_signed(is_signed), m_size(size)
     {
@@ -313,10 +330,6 @@ namespace elna::boot
 
     std::optional<std::ptrdiff_t> integer_literal::to_signed() const
     {
-        if (!is_signed())
-        {
-            return std::nullopt;
-        }
         if (is_negative_minimum(sizeof(std::ptrdiff_t) * CHAR_BIT))
         {
             return std::numeric_limits<ptrdiff_t>::min();
@@ -327,15 +340,11 @@ namespace elna::boot
         {
             return std::nullopt;
         }
-        return mpz_sgn(this->raw) < 0 ? -rop : rop;
+        return is_negative() ? -rop : rop;
     }
 
     std::optional<std::size_t> integer_literal::to_unsigned() const
     {
-        if (is_signed())
-        {
-            return std::nullopt;
-        }
         auto [written, rop] = export_to_words<std::size_t>();
 
         return written > 1 ? std::nullopt : std::make_optional(rop);
@@ -384,11 +393,11 @@ namespace elna::boot
     {
         std::size_t required_bits = mpz_sizeinbase(this->raw, 2);
 
-        if (!is_negative_minimum(bits))
+        if (!is_negative() || !is_negative_minimum(bits))
         {
             ++required_bits; // Add one bit for the sign.
         }
-        return required_bits <= bits && (mpz_sgn(this->raw) >= 0 || is_signed());
+        return required_bits <= bits && (!is_negative() || is_signed());
     }
 
     std::optional<integer_literal> integer_literal::check() &&
@@ -398,12 +407,12 @@ namespace elna::boot
 
     bool integer_literal::is_negative_minimum(const std::size_t bits) const
     {
-        return mpz_sgn(this->raw) < 0 && mpz_scan1(this->raw, 0) == bits - 1;
+        return mpz_scan1(this->raw, 0) == bits - 1;
     }
 
     bool integer_literal::is_negative_minimum() const
     {
-        return is_negative_minimum(bits());
+        return is_negative() && is_negative_minimum(bits());
     }
 
     std::size_t integer_literal::bits() const
@@ -411,6 +420,11 @@ namespace elna::boot
         return size() * CHAR_BIT;
     }
 
+    bool integer_literal::is_negative() const
+    {
+        return mpz_sgn(this->raw) < 0;
+    }
+
     std::size_t constant_value_hash::operator()(const elna::boot::constant_value& value) const noexcept
     {
         return std::visit([](auto&& alternative) -> std::size_t {
diff --git a/boot/symbol.cc b/boot/symbol.cc
index 6172621..1cc652c 100644
--- a/boot/symbol.cc
+++ b/boot/symbol.cc
@@ -165,19 +165,16 @@ namespace elna::boot
             }
             else if constexpr (std::is_same_v<T, std::shared_ptr<procedure_type>>)
             {
-                std::string result = "proc(";
-                for (std::size_t i = 0; i < payload->parameters.size(); ++i)
+                std::string result = "proc(" + join(payload->parameters) + ")";
+
+                if (payload->return_type.no_return)
                 {
-                    if (i > 0) { result += ", ";
-}
-                    result += payload->parameters[i].to_string();
-                }
-                result += ")";
-                if (payload->return_type.no_return) {
                     result += ": !";
-                } else if (!payload->return_type.proper_type.empty()) {
+                }
+                else if (!payload->return_type.proper_type.empty())
+                {
                     result += ": " + payload->return_type.proper_type.to_string();
-}
+                }
                 return result;
             }
             else if constexpr (std::is_same_v<T, std::shared_ptr<enumeration_type>>)
@@ -368,6 +365,12 @@ namespace elna::boot
         this->imports.push_front(bag.exported_symbols());
     }
 
+    bool symbol_bag::is_global() const
+    {
+        return this->symbols->scope() != nullptr
+            && this->symbols->scope()->scope() == nullptr;
+    }
+
     std::shared_ptr<symbol_table> symbol_bag::exported_symbols() const
     {
         if (!m_exported)
diff --git a/boot/validation.cc b/boot/validation.cc
index dc4b5b0..b29381a 100644
--- a/boot/validation.cc
+++ b/boot/validation.cc
@@ -17,14 +17,12 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "elna/boot/validation.h"
 
-#include <algorithm>
-#include <numeric>
 #include <unordered_map>
 
 namespace elna::boot
 {
     validation_error::validation_error(const source_position position, payload_type payload)
-        : error(position), payload(std::move(payload))
+        : error(position), payload(payload)
     {
     }
 
@@ -33,18 +31,10 @@ namespace elna::boot
         return std::visit([](const auto& payload) -> std::string {
             using T = std::decay_t<decltype(payload)>;
 
-            if constexpr (std::is_same_v<T, non_constant_initializer>)
-            {
-                return "Variable initializers must be constant expressions";
-            }
-            else if constexpr (std::is_same_v<T, duplicate_case>)
+            if constexpr (std::is_same_v<T, duplicate_case>)
             {
                 return "Duplicate case label";
             }
-            else if constexpr (std::is_same_v<T, non_constant_case_label>)
-            {
-                return "Case label must be a constant expression";
-            }
         }, this->payload);
     }
 
@@ -53,64 +43,27 @@ namespace elna::boot
         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, non_constant_initializer>)
-            {
-                std::string identifier_list = std::accumulate(
-                        std::next(payload.identifiers.begin()), payload.identifiers.end(),
-                        payload.identifiers.front().name(),
-                        [](const std::string& accumulator, const identifier& next) -> std::string {
-                            return accumulator + ", " + next.name();
-                        });
-                auto position_span = source_position(payload.identifiers.front().position().start(),
-                        payload.identifiers.back().position().end());
-                return std::make_pair(std::move(identifier_list), position_span);
-            }
-            else if constexpr (std::is_same_v<T, duplicate_case>)
+            if constexpr (std::is_same_v<T, duplicate_case>)
             {
                 return std::make_pair("Previous label here", payload.first);
             }
-            else if constexpr (std::is_same_v<T, non_constant_case_label>)
-            {
-                return std::nullopt;
-            }
         }, this->payload);
     }
 
-    validation_error validation_error::non_constant_initializer_error(const source_position position,
-            const std::vector<identifier_definition>& identifiers)
-    {
-        non_constant_initializer payload;
-        payload.identifiers.reserve(identifiers.size());
-
-        std::ranges::transform(identifiers, std::back_inserter(payload.identifiers),
-                [](const auto& identifier) { return identifier.id(); });
-
-        return validation_error(position, std::move(payload));
-    }
-
     validation_visitor::validation_visitor(symbol_bag& bag, const target_info& target)
-        : bag(bag), target(target), constant_evaluator(this->bag, this->target)
+        : bag(bag), constant_evaluator(this->bag, target)
     {
     }
 
-    void validation_visitor::visit(variable_declaration* declaration)
+    void validation_visitor::visit(unit *unit)
     {
-        if (declaration->initializer == nullptr || has_errors())
-        {
-            return;
-        }
-        auto computed = this->constant_evaluator.evaluate(*declaration->initializer);
-        if (!computed)
+        for (procedure_declaration *procedure : unit->procedures)
         {
-            auto non_constant_initializer_error = validation_error::non_constant_initializer_error(
-                    declaration->initializer->position(), declaration->identifiers);
-            add_error<validation_error>(non_constant_initializer_error);
-            return;
+            procedure->accept(this);
         }
-        for (const auto& identifier : declaration->identifiers)
+        for (auto *entry_statement : unit->entry_point)
         {
-            auto variable_symbol = this->bag.lookup(identifier.name())->is_variable();
-            variable_symbol->value = computed;
+            entry_statement->accept(this);
         }
     }
 
@@ -139,8 +92,8 @@ namespace elna::boot
                 auto value = this->constant_evaluator.evaluate(*label);
                 if (!value.has_value())
                 {
-                    add_error<validation_error>(label->position(),
-                            validation_error::non_constant_case_label{});
+                    add_error<non_constant_expression_error>(label->position(),
+                            non_constant_expression_error::case_label{});
                     continue;
                 }
                 auto [case_position, inserted] = seen.try_emplace(value.value(), label->position());
diff --git a/include/elna/boot/ast.h b/include/elna/boot/ast.h
index 996c58a..1ea17fb 100644
--- a/include/elna/boot/ast.h
+++ b/include/elna/boot/ast.h
@@ -17,7 +17,6 @@ along with GCC; see the file COPYING3.  If not see
 
 #pragma once
 
-#include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>
@@ -316,18 +315,19 @@ namespace elna::boot
     class array_type_expression : public type_expression
     {
         type_expression *m_base;
+        expression *m_dimensions;
 
     public:
-        const std::uint32_t size;
 
         array_type_expression(const source_position position,
-                type_expression *base, const std::uint32_t size);
+                type_expression *base, expression *dimensions);
         ~array_type_expression() override;
 
         void accept(parser_visitor *visitor) override;
         array_type_expression *is_array() override;
 
-        type_expression& base();
+        type_expression& base() const;
+        expression& dimensions() const;
     };
 
     class slice_type_expression : public type_expression
@@ -415,7 +415,7 @@ namespace elna::boot
     {
     public:
         const identifier type_name;
-        std::vector<field_initializer> field_initializers;
+        const std::vector<field_initializer> field_initializers;
 
         record_constructor_expression(const source_position position,
                 identifier&& type_name,
@@ -426,17 +426,18 @@ namespace elna::boot
 
     class array_constructor_expression : public expression
     {
+        array_type_expression *m_element_type;
+
     public:
-        const std::uint32_t size;
-        type_expression *const m_element_type;
-        std::vector<expression *> elements;
+        const std::vector<expression *> elements;
 
         array_constructor_expression(const source_position position,
-                std::uint32_t size, type_expression *element_type,
-                std::vector<expression *>&& elements);
+                array_type_expression *element_type, std::vector<expression *>&& elements);
         void accept(parser_visitor *visitor) override;
         array_constructor_expression *is_array_constructor() override;
 
+        array_type_expression& array_type() const;
+
         ~array_constructor_expression() override;
     };
 
diff --git a/include/elna/boot/driver.h b/include/elna/boot/driver.h
index 34a8c99..60d40fb 100644
--- a/include/elna/boot/driver.h
+++ b/include/elna/boot/driver.h
@@ -35,7 +35,7 @@ namespace elna::boot
         std::string what() const override;
     };
 
-    class driver : public error_container
+    class driver final : public error_container
     {
     public:
         std::unique_ptr<unit> tree;
diff --git a/include/elna/boot/evaluator.h b/include/elna/boot/evaluator.h
index 84bd5ab..0d1a7c8 100644
--- a/include/elna/boot/evaluator.h
+++ b/include/elna/boot/evaluator.h
@@ -22,9 +22,35 @@ along with GCC; see the file COPYING3.  If not see
 
 #include <memory>
 #include <optional>
+#include <variant>
 
 namespace elna::boot
 {
+    class non_constant_expression_error final : public error
+    {
+    public:
+        struct initializer
+        {
+            std::vector<identifier> identifiers;
+        };
+        struct case_label
+        {
+        };
+        struct array_dimensions
+        {
+            type array_type;
+        };
+        using payload_type = std::variant<initializer, case_label, array_dimensions>;
+
+        non_constant_expression_error(const source_position position, payload_type payload);
+
+        std::string what() const override;
+        std::optional<std::pair<std::string, source_position>> note() const override;
+
+    private:
+        payload_type payload;
+    };
+
     std::optional<type_properties> get_type_properties(const type& subject, const target_info& target);
 
     /**
@@ -53,7 +79,6 @@ namespace elna::boot
         std::optional<constant_value> evaluate_named(named_expression& subject);
         std::optional<constant_value> evaluate_array_access(array_access_expression& subject);
         std::optional<constant_value> evaluate_field_access(field_access_expression& subject);
-        std::optional<std::size_t> evaluate_index(expression& subject);
         std::optional<constant_value> evaluate_slicing(slicing_expression& subject);
         std::optional<constant_value> evaluate_unary(unary_expression& subject);
         std::optional<constant_value> evaluate_binary(binary_expression& subject);
@@ -62,6 +87,7 @@ namespace elna::boot
         std::optional<std::size_t> evaluate_traits_alignment(const type& subject);
 
     public:
+        std::optional<std::size_t> evaluate_index(expression& subject);
         std::optional<constant_value> evaluate_traits(traits_expression& subject);
         explicit evaluator(symbol_bag& bag, const target_info& target);
 
diff --git a/include/elna/boot/name_analysis.h b/include/elna/boot/name_analysis.h
index 996c357..f6663ea 100644
--- a/include/elna/boot/name_analysis.h
+++ b/include/elna/boot/name_analysis.h
@@ -20,6 +20,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "elna/boot/ast.h"
 #include "elna/boot/result.h"
 #include "elna/boot/symbol.h"
+#include "elna/boot/evaluator.h"
 
 #include <string>
 #include <memory>
@@ -32,7 +33,7 @@ namespace elna::boot
      * Error declaring or using a symbol (undeclared, redefinition,
      * local export).
      */
-    class declaration_error : public error
+    class declaration_error final : public error
     {
     public:
         enum class kind { undeclared_type, undeclared_trait, undeclared_symbol, local_export };
@@ -56,7 +57,7 @@ namespace elna::boot
      * \c const qualifier used incorrectly — wrong position or
      * duplicate.
      */
-    class const_qualifier_error : public error
+    class const_qualifier_error final : public error
     {
     public:
         enum class kind { array_position, duplicate };
@@ -72,7 +73,7 @@ namespace elna::boot
     /**
      * Error accessing or defining a member of a record or enumeration.
      */
-    class member_error : public error
+    class member_error final : public error
     {
     public:
         enum class kind { not_found, field_on_type };
@@ -94,6 +95,17 @@ namespace elna::boot
         payload_type payload;
     };
 
+    class not_initialized_error final : public error
+    {
+        std::vector<identifier> identifiers;
+
+    public:
+        not_initialized_error(const source_position position, std::vector<identifier> identifiers);
+
+        std::string what() const override;
+        std::optional<std::pair<std::string, source_position>> note() const override;
+    };
+
     /**
      * Origin of a field in a composite type.
      */
@@ -109,8 +121,8 @@ namespace elna::boot
     class name_analysis_visitor final : public walking_visitor, public error_container
     {
         type current_type;
-
         symbol_bag bag;
+        evaluator constant_evaluator;
 
         std::pair<procedure_type, std::vector<std::string>> build_procedure(
                 procedure_type_expression& expression);
@@ -125,7 +137,7 @@ namespace elna::boot
                 const type& element_type);
 
     public:
-        name_analysis_visitor(symbol_bag bag);
+        name_analysis_visitor(symbol_bag bag, const target_info& target);
 
         void visit(array_type_expression *expression) override;
         void visit(slice_type_expression *expression) override;
diff --git a/include/elna/boot/result.h b/include/elna/boot/result.h
index 36be8ee..3d01eb2 100644
--- a/include/elna/boot/result.h
+++ b/include/elna/boot/result.h
@@ -23,6 +23,7 @@ along with GCC; see the file COPYING3.  If not see
 #include <string>
 #include <deque>
 #include <memory>
+#include <numeric>
 #include <optional>
 #include <utility>
 #include <variant>
@@ -158,6 +159,8 @@ namespace elna::boot
         const std::string& name() const;
         const source_position& position() const;
 
+        std::string to_string() const;
+
         bool operator==(const identifier& that) const;
         bool operator==(std::string_view that) const;
 
@@ -181,6 +184,44 @@ namespace elna::boot
     };
 
     /**
+     * Checks whether the givn object can be converted to a string using
+     * the .to_string() method.
+     */
+    template<typename T>
+    concept has_to_string = requires(const T& stringable) {
+        { stringable.to_string() } -> std::convertible_to<std::string>;
+    };
+
+    /**
+     * Extracts identifiers (name and position) from identifier definitions and
+     * returns them in an allocated vector.
+     *
+     * \param identifiers Identifier definitions.
+     * \return Extracted identifiers.
+     */
+    std::vector<identifier> extract_identifiers(const std::vector<identifier_definition>& identifiers);
+
+    /**
+     * Joins an array of string-convertable objects (with a .t_string() method)
+     * into a delimiter separated list.
+     *
+     * \tparam T Array element type.
+     * \param identifiers Identifier array.
+     * \param delimiter List delimiter.
+     * \return Comma separted list.
+     */
+    template<has_to_string T>
+    std::string join(const std::vector<T>& identifiers, std::string_view delimiter = ", ")
+    {
+        return std::accumulate(std::next(identifiers.begin()), identifiers.end(),
+                identifiers.front().to_string(),
+                [delimiter](const std::string& accumulator, const T& next) -> std::string {
+                    return accumulator + std::string(delimiter) + next.to_string();
+                }
+        );
+    }
+
+    /**
      * Checks whether \p T is a signed, std::int*_t type.
      *
      * \tparam T The examined type.
@@ -271,6 +312,11 @@ namespace elna::boot
         std::string to_string(const std::uint8_t base = 10U) const;
 
         /**
+         * \return Whether the stored value is a negative integer.
+         */
+        bool is_negative() const;
+
+        /**
          * Exports the stored value as a host \c std::ptrdiff_t.
          *
          * \return The converted value, or \c std::nullopt if out of range.
diff --git a/include/elna/boot/symbol.h b/include/elna/boot/symbol.h
index 5000ab8..bd07a7e 100644
--- a/include/elna/boot/symbol.h
+++ b/include/elna/boot/symbol.h
@@ -494,11 +494,17 @@ namespace elna::boot
          */
         void add_import(const symbol_bag& bag);
 
-    private:
         /**
-         * Returns a reduced symbol table with exported symbols, computed lazily
-         * and cached.
+         * Tells whether the current scope is the module global scope.
+         *
+         * The module scope is not the top-level scope, it's parent is the
+         * scope containing builtins.
+         *
+         * \return Whether the current scope is the global scope.
          */
+        bool is_global() const;
+
+    private:
         std::shared_ptr<symbol_table> exported_symbols() const;
 
         mutable std::shared_ptr<symbol_table> m_exported;
diff --git a/include/elna/boot/type_check.h b/include/elna/boot/type_check.h
index 82f0092..93e891a 100644
--- a/include/elna/boot/type_check.h
+++ b/include/elna/boot/type_check.h
@@ -30,7 +30,7 @@ namespace elna::boot
     /**
      * Expected type does not match the actual type of an expression.
      */
-    class type_mismatch_error : public error
+    class type_mismatch_error final : public error
     {
     public:
         struct expected_type
@@ -90,7 +90,7 @@ namespace elna::boot
     /**
      * Cyclic type declaration.
      */
-    class cyclic_declaration_error : public error
+    class cyclic_declaration_error final : public error
     {
         std::vector<std::string> cycle;
 
@@ -104,7 +104,7 @@ namespace elna::boot
      * Argument count in a procedure call or array constructor doesn't match
      * the expected number of parameters or elements.
      */
-    class argument_count_error : public error
+    class argument_count_error final : public error
     {
         std::size_t expected;
         std::size_t actual;
@@ -119,7 +119,7 @@ namespace elna::boot
     /**
      * A trait invocation is invalid.
      */
-    class trait_error : public error
+    class trait_error final : public error
     {
     public:
         struct argument_count
diff --git a/include/elna/boot/validation.h b/include/elna/boot/validation.h
index c11a652..4a256fa 100644
--- a/include/elna/boot/validation.h
+++ b/include/elna/boot/validation.h
@@ -27,30 +27,20 @@ namespace elna::boot
     /**
      * Validation error.
      */
-    class validation_error : public error
+    class validation_error final : public error
     {
     public:
-        struct non_constant_initializer
-        {
-            std::vector<identifier> identifiers;
-        };
         struct duplicate_case
         {
             source_position first;
         };
-        struct non_constant_case_label
-        {
-        };
-        using payload_type = std::variant<non_constant_initializer, duplicate_case, non_constant_case_label>;
+        using payload_type = std::variant<duplicate_case>;
 
         validation_error(const source_position position, payload_type payload);
 
         std::string what() const override;
         std::optional<std::pair<std::string, source_position>> note() const override;
 
-        static validation_error non_constant_initializer_error(const source_position position,
-                const std::vector<identifier_definition>& identifiers);
-
     private:
         payload_type payload;
     };
@@ -58,19 +48,17 @@ namespace elna::boot
     /**
      * Validates:
      * - case label uniqueness
-     * - Initializer constness.
      */
     class validation_visitor final : public walking_visitor, public error_container
     {
         symbol_bag& bag;
-        const target_info& target;
         evaluator constant_evaluator;
 
     public:
         validation_visitor(symbol_bag& bag, const target_info& target);
 
-        void visit(variable_declaration* declaration) override;
-        void visit(procedure_declaration* declaration) override;
+        void visit(unit *unit) override;
+        void visit(procedure_declaration *declaration) override;
         void visit(case_statement *statement) override;
     };
 }
diff --git a/testsuite/compilable/compile_time_array_length.elna b/testsuite/compilable/compile_time_array_length.elna
index 1ce8956..12e706f 100644
--- a/testsuite/compilable/compile_time_array_length.elna
+++ b/testsuite/compilable/compile_time_array_length.elna
@@ -1,5 +1,5 @@
 var
-  source: [3]Int := [3]Int{ 1, 2, 3}
+  source: const [3]Int := [3]Int{ 1, 2, 3 }
   target: Word := source.length
 
 end.
diff --git a/testsuite/compilable/const_alias.elna b/testsuite/compilable/const_alias.elna
index 9cb9ffb..e17c55f 100644
--- a/testsuite/compilable/const_alias.elna
+++ b/testsuite/compilable/const_alias.elna
@@ -3,8 +3,8 @@ type
   CCI = const CI
 
 var
-  x: CCI
-  y: const CI
+  x: CCI := 8
+  y: const CI := 9
 
 begin
 end.
diff --git a/testsuite/compilable/take_const_address.elna b/testsuite/compilable/take_const_address.elna
index 54a2992..f8c9e5c 100644
--- a/testsuite/compilable/take_const_address.elna
+++ b/testsuite/compilable/take_const_address.elna
@@ -1,6 +1,6 @@
 var
   x: ^const Int
-  y: const Int
+  y: const Int := 1
 
 begin
   x := @y
diff --git a/testsuite/fail_compilation/assign_const_primitive.elna b/testsuite/fail_compilation/assign_const_primitive.elna
index 34b095b..22fef25 100644
--- a/testsuite/fail_compilation/assign_const_primitive.elna
+++ b/testsuite/fail_compilation/assign_const_primitive.elna
@@ -1,6 +1,6 @@
 proc f()
 var
-  x: const Int
+  x: const Int := 4
 begin
   x := 5 (* @Error Cannot assign to a value of type 'const Int', because it is constant or contains constant members *)
 return
diff --git a/testsuite/fail_compilation/assign_const_to_pointer.elna b/testsuite/fail_compilation/assign_const_to_pointer.elna
index c3d9230..87047e5 100644
--- a/testsuite/fail_compilation/assign_const_to_pointer.elna
+++ b/testsuite/fail_compilation/assign_const_to_pointer.elna
@@ -1,5 +1,5 @@
 var
-  c: const Int
+  c: const Int := 2
   p: Pointer
 
 begin
diff --git a/testsuite/fail_compilation/assign_element_of_const.elna b/testsuite/fail_compilation/assign_element_of_const.elna
index 9afd520..a5b5cda 100644
--- a/testsuite/fail_compilation/assign_element_of_const.elna
+++ b/testsuite/fail_compilation/assign_element_of_const.elna
@@ -1,6 +1,6 @@
 proc f()
 var
-  a: const [2]Int
+  a: const [2]Int := [2]Int{ 1, 3 }
 begin
   a[1] := 6 (* @Error Cannot assign to a value of type 'const Int', because it is constant or contains constant members *)
 return
diff --git a/testsuite/fail_compilation/assign_from_const_pointer.elna b/testsuite/fail_compilation/assign_from_const_pointer.elna
index 164bb42..c39d5cd 100644
--- a/testsuite/fail_compilation/assign_from_const_pointer.elna
+++ b/testsuite/fail_compilation/assign_from_const_pointer.elna
@@ -1,5 +1,5 @@
 var
-  cv: const Pointer
+  cv: const Pointer := nil
   p: Pointer
 
 begin
diff --git a/testsuite/fail_compilation/const_uninitialized.elna b/testsuite/fail_compilation/const_uninitialized.elna
new file mode 100644
index 0000000..06db3d7
--- /dev/null
+++ b/testsuite/fail_compilation/const_uninitialized.elna
@@ -0,0 +1,4 @@
+var
+  x: const Int (* @Error All constants should be initialized *)
+
+end.