diff options
25 files changed, 558 insertions, 395 deletions
diff --git a/boot/ast.cc b/boot/ast.cc index 37e89ac..3454cce 100644 --- a/boot/ast.cc +++ b/boot/ast.cc @@ -29,6 +29,11 @@ namespace elna::boot __builtin_unreachable(); } + void empty_visitor::visit(constant_type_expression *) + { + __builtin_unreachable(); + } + void empty_visitor::visit(type_declaration *) { __builtin_unreachable(); @@ -54,11 +59,6 @@ namespace elna::boot __builtin_unreachable(); } - void empty_visitor::visit(constant_declaration *) - { - __builtin_unreachable(); - } - void empty_visitor::visit(procedure_declaration *) { __builtin_unreachable(); @@ -210,10 +210,6 @@ namespace elna::boot } if (declaration->body.has_value()) { - for (constant_declaration *const constant : declaration->body.value().constants) - { - constant->accept(this); - } for (variable_declaration *const variable : declaration->body.value().variables) { variable->accept(this); @@ -336,10 +332,6 @@ namespace elna::boot { variable->accept(this); } - for (constant_declaration *const constant : unit->constants) - { - constant->accept(this); - } for (procedure_declaration *const procedure : unit->procedures) { procedure->accept(this); @@ -364,17 +356,17 @@ namespace elna::boot } } - void walking_visitor::visit(constant_declaration *declaration) + void walking_visitor::visit(array_type_expression *expression) { - declaration->initializer().accept(this); + expression->base().accept(this); } - void walking_visitor::visit(array_type_expression *expression) + void walking_visitor::visit(pointer_type_expression *expression) { expression->base().accept(this); } - void walking_visitor::visit(pointer_type_expression *expression) + void walking_visitor::visit(constant_type_expression *expression) { expression->base().accept(this); } @@ -557,6 +549,11 @@ namespace elna::boot return nullptr; } + constant_type_expression *type_expression::is_constant() + { + return nullptr; + } + record_type_expression *type_expression::is_record() { return nullptr; @@ -624,6 +621,32 @@ namespace elna::boot return *m_base; } + constant_type_expression::constant_type_expression(const source_position position, + type_expression *base) + : node(position), m_base(base) + { + } + + constant_type_expression::~constant_type_expression() + { + delete m_base; + } + + void constant_type_expression::accept(parser_visitor *visitor) + { + visitor->visit(this); + } + + constant_type_expression *constant_type_expression::is_constant() + { + return this; + } + + type_expression& constant_type_expression::base() + { + return *m_base; + } + record_type_expression::record_type_expression(const source_position position, std::vector<field_declaration>&& fields) : node(position), fields(std::move(fields)) @@ -753,27 +776,6 @@ namespace elna::boot { } - constant_declaration::constant_declaration(const source_position position, identifier_definition identifier, - expression *initializer) - : declaration(position, identifier), m_initializer(initializer) - { - } - - void constant_declaration::accept(parser_visitor *visitor) - { - visitor->visit(this); - } - - expression& constant_declaration::initializer() - { - return *m_initializer; - } - - constant_declaration::~constant_declaration() - { - delete m_initializer; - } - procedure_type_expression::procedure_type_expression(const source_position position, std::vector<field_declaration>&& parameters, return_t return_type) : node(position), return_type(return_type), parameters(std::move(parameters)) @@ -863,17 +865,15 @@ namespace elna::boot return *m_underlying_type; } - procedure_body::procedure_body(std::vector<constant_declaration *>&& constants, - std::vector<variable_declaration *>&& variables, std::vector<statement *>&& entry_point, - expression *return_expr) - : constants(std::move(constants)), variables(std::move(variables)), - entry_point(std::move(entry_point)), return_expression(return_expr) + procedure_body::procedure_body(std::vector<variable_declaration *>&& variables, + std::vector<statement *>&& entry_point, expression *return_expression) + : variables(std::move(variables)), + entry_point(std::move(entry_point)), return_expression(return_expression) { } procedure_body::procedure_body(procedure_body&& that) - : constants(std::move(const_cast<std::vector<constant_declaration *>&>(that.constants))), - variables(std::move(const_cast<std::vector<variable_declaration *>&>(that.variables))), + : variables(std::move(const_cast<std::vector<variable_declaration *>&>(that.variables))), entry_point(std::move(const_cast<std::vector<statement *>&>(that.entry_point))), return_expression(that.return_expression) { @@ -889,27 +889,22 @@ namespace elna::boot { delete variable; } - for (constant_declaration *constant : this->constants) - { - delete constant; - } } unit::unit(const source_position position) - : node(position), procedure_body(std::vector<constant_declaration *>{}, - std::vector<variable_declaration *>{}, std::vector<statement *>{}, nullptr) + : node(position), + procedure_body(std::vector<variable_declaration *>{}, std::vector<statement *>{}, nullptr) { } unit::unit(const source_position position, std::vector<import_declaration *>&& imports, - std::vector<constant_declaration *>&& constants, std::vector<type_declaration *>&& types, std::vector<variable_declaration *>&& variables, std::vector<procedure_declaration *>&& procedures, std::vector<statement *>&& entry_point) : node(position), - procedure_body(std::move(constants), std::move(variables), std::move(entry_point)), + procedure_body(std::move(variables), std::move(entry_point)), imports(std::move(imports)), types(std::move(types)), procedures(std::move(procedures)) { } diff --git a/boot/parser.yy b/boot/parser.yy index c34c905..1dd42a8 100644 --- a/boot/parser.yy +++ b/boot/parser.yy @@ -129,8 +129,6 @@ along with GCC; see the file COPYING3. If not see %type <std::vector<elna::boot::expression *>> case_labels; %type <elna::boot::switch_case> switch_case; %type <std::vector<elna::boot::switch_case>> switch_cases; -%type <elna::boot::constant_declaration *> constant_declaration; -%type <std::vector<elna::boot::constant_declaration *>> constant_part constant_declarations; %type <elna::boot::variable_declaration *> variable_declaration; %type <std::vector<elna::boot::variable_declaration *>> variable_declarations variable_part; %type <elna::boot::type_expression *> type_expression; @@ -166,14 +164,14 @@ along with GCC; see the file COPYING3. If not see %type <std::vector<elna::boot::import_declaration *>> import_declarations import_part; %% program: - import_part constant_part type_part variable_part procedure_part statement_part "end" "." + import_part type_part variable_part procedure_part statement_part "end" "." { - boot::unit *tree = new boot::unit(boot::make_position(@$), $1, $2, $3, $4, $5, $6); + boot::unit *tree = new boot::unit(boot::make_position(@$), $1, $2, $3, $4, $5); driver.tree.reset(tree); } procedure_body: - constant_part variable_part statement_part procedure_return - { $$ = std::make_unique<boot::procedure_body>($1, $2, $3, $4); } + variable_part statement_part procedure_return + { $$ = std::make_unique<boot::procedure_body>($1, $2, $3); } statement_part: /* no statements */ {} @@ -444,6 +442,10 @@ type_expression: { $$ = new boot::array_type_expression(boot::make_position(@$), $4, $2); } + | "const" type_expression + { + $$ = new boot::constant_type_expression(boot::make_position(@$), $2); + } | "^" type_expression { $$ = new boot::pointer_type_expression(boot::make_position(@$), $2); @@ -501,20 +503,6 @@ variable_declarations: variable_part: /* no variable declarations */ {} | "var" variable_declarations { $$ = $2; } -constant_declaration: identifier_definition ":=" expression - { - $$ = new boot::constant_declaration(boot::make_position(@$), std::move(*$1), $3); - } -constant_declarations: - constant_declaration constant_declarations - { - $$ = $2; - $$.insert(std::cbegin($$), $1); - } - | /* no constant definitions */ {} -constant_part: - /* no constant definitions */ {} - | "const" constant_declarations { $$ = $2; } import_declaration: IDENTIFIER "." import_declaration { diff --git a/boot/semantic.cc b/boot/semantic.cc index 9137053..c987cfd 100644 --- a/boot/semantic.cc +++ b/boot/semantic.cc @@ -73,6 +73,18 @@ namespace elna::boot + "', but got '" + actual.to_string() + "'"; } + constant_assignment_error::constant_assignment_error(const source_position position, + type assignee) + : error(position), assignee(assignee) + { + } + + std::string constant_assignment_error::what() const + { + return "Cannot assign to a value of type '" + assignee.to_string() + + "', because it is constant or contains constant members"; + } + field_not_found_error::field_not_found_error(const identifier& field_name, type composite_type) : error(field_name.position()), field_name(field_name.name()), composite_type(composite_type) @@ -81,7 +93,7 @@ namespace elna::boot std::string field_not_found_error::what() const { - type resolved = inner_aliased_type(composite_type); + type resolved = resolve_underlying_type(composite_type); bool is_enum = resolved.get<enumeration_type>() != nullptr; bool is_record = resolved.get<record_type>() != nullptr; @@ -112,7 +124,7 @@ namespace elna::boot std::string duplicate_member_error::what() const { - type resolved = inner_aliased_type(aggregate); + type resolved = resolve_underlying_type(aggregate); bool is_enum = resolved.get<enumeration_type>() != nullptr; std::string kind = is_enum ? "member" : "field"; std::string message = is_enum ? "Enumeration" : "Record"; @@ -208,7 +220,7 @@ namespace elna::boot unsupported_trait_type_error::unsupported_trait_type_error(const identifier& trait, type actual) - : error(trait.position()), trait_name(trait.name()), actual(actual) + : error(trait.position()), actual(actual), trait_name(trait.name()) { } @@ -218,6 +230,119 @@ namespace elna::boot + "' does not support trait '#" + trait_name + "'"; } + // Members of a constant aggregate are constant themselves. + static type qualify_member_type(const type& element, const type& aggregate) + { + if (resolve_aliases(aggregate).get<constant_type>() != nullptr + && resolve_aliases(element).get<constant_type>() == nullptr) + { + return type(std::make_shared<constant_type>(element)); + } + else + { + return element; + } + } + + /* + * Whether the type itself is constant or has a constant member at any + * nesting level, so that values of this type cannot be reassigned as a + * whole. Pointers to constants do not make the type itself constant. + */ + static bool contains_constant_member(const type& checked) + { + auto referent = resolve_aliases(checked); + + if (referent.get<constant_type>() != nullptr) + { + return true; + } + else if (auto record = referent.get<record_type>()) + { + for (const type_field& field : record->fields) + { + if (contains_constant_member(field.second)) + { + return true; + } + } + return !record->base.empty() && contains_constant_member(record->base); + } + else if (auto array = referent.get<array_type>()) + { + return contains_constant_member(array->base); + } + return false; + } + + bool type_analysis_visitor::check_unresolved_symbol(std::shared_ptr<alias_type> alias, + std::vector<std::string>& alias_path) + { + if (std::find(std::cbegin(alias_path), std::cend(alias_path), alias->name) != std::cend(alias_path)) + { + return false; + } + alias_path.push_back(alias->name); + + if (auto another_alias = alias->reference.get<alias_type>()) + { + return check_unresolved_symbol(another_alias, alias_path); + } + return true; + } + + bool type_analysis_visitor::is_base_of(const std::shared_ptr<record_type>& base, + const std::shared_ptr<record_type>& derived) + { + if (derived != nullptr) + { + if (auto current_record = resolve_underlying_type(derived->base).get<record_type>()) + { + return current_record == base || is_base_of(base, current_record); + } + } + return false; + } + + bool type_analysis_visitor::is_assignable_from(const type& assignee, const type& assignment) + { + type resolved_assignee = resolve_underlying_type(assignee); + type resolved_assignment = resolve_underlying_type(assignment); + + if (resolved_assignee == resolved_assignment + || (is_primitive_type(resolved_assignee, "Pointer") && is_any_pointer_type(resolved_assignment)) + || (is_primitive_type(resolved_assignment, "Pointer") && is_any_pointer_type(resolved_assignee))) + { + return true; + } + std::shared_ptr<pointer_type> assignee_pointer = resolved_assignee.get<pointer_type>(); + std::shared_ptr<pointer_type> assignment_pointer = resolved_assignment.get<pointer_type>(); + + if (assignee_pointer == nullptr || assignment_pointer == nullptr) + { + return false; + } + auto assignee_pointee_const = resolve_aliases(assignee_pointer->base).get<constant_type>(); + auto assignment_pointee_const = resolve_aliases(assignment_pointer->base).get<constant_type>(); + + // Constness can be added at the first indirection level, but not removed. + if (assignee_pointee_const != nullptr + && assignee_pointee_const->unqualified == assignment_pointer->base) + { + return true; + } + if (assignment_pointee_const != nullptr && assignee_pointee_const == nullptr) + { + return false; + } + // A pointer to a record can be assigned to a pointer to its base type. + std::shared_ptr<record_type> assignee_record = + resolve_underlying_type(assignee_pointer->base).get<record_type>(); + + return assignee_record != nullptr + && is_base_of(assignee_record, resolve_underlying_type(assignment_pointer->base).get<record_type>()); + } + type_analysis_visitor::type_analysis_visitor(symbol_bag bag) : error_container(), bag(bag) { @@ -272,7 +397,12 @@ namespace elna::boot { walking_visitor::visit(statement); - if (!is_assignable_from(statement->lvalue().type_decoration, statement->rvalue().type_decoration)) + if (contains_constant_member(statement->lvalue().type_decoration)) + { + add_error<constant_assignment_error>(statement->position(), + statement->lvalue().type_decoration); + } + else if (!is_assignable_from(statement->lvalue().type_decoration, statement->rvalue().type_decoration)) { add_error<type_mismatch_error>(statement->position(), statement->lvalue().type_decoration, statement->rvalue().type_decoration); @@ -302,7 +432,7 @@ namespace elna::boot void type_analysis_visitor::visit(case_statement *statement) { walking_visitor::visit(statement); - type condition_type = inner_aliased_type(statement->condition().type_decoration); + type condition_type = resolve_underlying_type(statement->condition().type_decoration); for (const switch_case& case_block : statement->cases) { @@ -317,22 +447,6 @@ namespace elna::boot } } - bool type_analysis_visitor::check_unresolved_symbol(std::shared_ptr<alias_type> alias, - std::vector<std::string>& alias_path) - { - if (std::find(std::cbegin(alias_path), std::cend(alias_path), alias->name) != std::cend(alias_path)) - { - return false; - } - alias_path.push_back(alias->name); - - if (auto another_alias = alias->reference.get<alias_type>()) - { - return check_unresolved_symbol(another_alias, alias_path); - } - return true; - } - void type_analysis_visitor::visit(type_declaration *declaration) { std::vector<std::string> alias_path; @@ -352,7 +466,7 @@ namespace elna::boot { if (expression->base.has_value()) { - type base_type = inner_aliased_type(this->bag.lookup(expression->base.value().name())->is_type()->symbol); + type base_type = resolve_underlying_type(this->bag.lookup(expression->base.value().name())->is_type()->symbol); if (base_type.get<record_type>() == nullptr) { add_error<base_type_error>(base_type, expression->position()); @@ -393,7 +507,7 @@ namespace elna::boot void type_analysis_visitor::visit(record_constructor_expression *expression) { - auto record = inner_aliased_type(expression->type_decoration).get<record_type>(); + auto record = resolve_underlying_type(expression->type_decoration).get<record_type>(); if (record == nullptr) { @@ -422,7 +536,7 @@ namespace elna::boot void type_analysis_visitor::visit(array_constructor_expression *expression) { - auto array = inner_aliased_type(expression->type_decoration).get<array_type>(); + auto array = resolve_underlying_type(expression->type_decoration).get<array_type>(); if (array == nullptr) { @@ -490,49 +604,9 @@ namespace elna::boot return this->bag.lookup(name)->is_type()->symbol; } - type name_analysis_visitor::type_of_constant(const constant_info::variant& value) - { - return std::visit([this](auto&& arg) -> type { - using T = std::decay_t<decltype(arg)>; - - if constexpr (std::is_same_v<T, std::int32_t>) - { - return lookup_primitive_type("Int"); - } - else if constexpr (std::is_same_v<T, std::uint32_t>) - { - return lookup_primitive_type("Word"); - } - else if constexpr (std::is_same_v<T, double>) - { - return lookup_primitive_type("Float"); - } - else if constexpr (std::is_same_v<T, bool>) - { - return lookup_primitive_type("Bool"); - } - else if constexpr (std::is_same_v<T, unsigned char>) - { - return lookup_primitive_type("Char"); - } - else if constexpr (std::is_same_v<T, std::nullptr_t>) - { - return lookup_primitive_type("Pointer"); - } - else if constexpr (std::is_same_v<T, std::string>) - { - return lookup_primitive_type("String"); - } - else - { - static_assert(!sizeof(T*), "Unhandled constant type"); - } - }, value); - } - type name_analysis_visitor::lookup_field(const type& composite_type, const std::string& field_name) { - type resolved_type = inner_aliased_type(composite_type); + type resolved_type = resolve_underlying_type(composite_type); if (auto record = resolved_type.get<record_type>()) { @@ -579,6 +653,12 @@ namespace elna::boot this->current_type = type(std::make_shared<pointer_type>(this->current_type)); } + void name_analysis_visitor::visit(constant_type_expression *expression) + { + walking_visitor::visit(expression); + this->current_type = type(std::make_shared<constant_type>(this->current_type)); + } + void name_analysis_visitor::visit(array_type_expression *expression) { walking_visitor::visit(expression); @@ -593,7 +673,7 @@ namespace elna::boot static void collect_field_names(const type& composite_type, std::map<std::string, field_origin>& names) { - auto record = inner_aliased_type(composite_type).get<record_type>(); + auto record = resolve_underlying_type(composite_type).get<record_type>(); if (record == nullptr) { return; @@ -803,15 +883,6 @@ namespace elna::boot } } - void name_analysis_visitor::visit(constant_declaration *declaration) - { - walking_visitor::visit(declaration); - auto constant_symbol = std::make_shared<constant_info>(this->current_literal); - - constant_symbol->exported = declaration->identifier.exported(); - constant_symbol->position.emplace(declaration->position()); - this->bag.enter(declaration->identifier.name(), constant_symbol); - } void name_analysis_visitor::visit(procedure_declaration *declaration) { @@ -833,10 +904,6 @@ namespace elna::boot ++name_iterator; ++type_iterator; } - for (constant_declaration *const constant : declaration->body.value().constants) - { - constant->accept(this); - } for (variable_declaration *const variable : declaration->body.value().variables) { variable->accept(this); @@ -887,10 +954,6 @@ namespace elna::boot { variable->accept(this); } - for (constant_declaration *const constant : unit->constants) - { - constant->accept(this); - } for (procedure_declaration *const procedure : unit->procedures) { procedure->accept(this); @@ -932,7 +995,7 @@ namespace elna::boot if (!trait->type_decoration.empty()) { - type resolved = inner_aliased_type(trait->type_decoration); + type resolved = resolve_underlying_type(trait->type_decoration); bool is_enum = resolved.get<enumeration_type>() != nullptr; bool is_integral = false; @@ -1005,7 +1068,7 @@ namespace elna::boot void name_analysis_visitor::visit(array_access_expression *expression) { walking_visitor::visit(expression); - auto resolved_base= inner_aliased_type(expression->base().type_decoration); + auto resolved_base = resolve_underlying_type(expression->base().type_decoration); if (auto array = resolved_base.get<array_type>()) { @@ -1015,6 +1078,13 @@ namespace elna::boot { expression->type_decoration = lookup_primitive_type("Char"); } + // Elements of a constant array are constant themselves since a static + // array is a holistic type. + if (!expression->type_decoration.empty()) + { + expression->type_decoration = qualify_member_type(expression->type_decoration, + expression->base().type_decoration); + } } void name_analysis_visitor::visit(field_access_expression *expression) @@ -1029,7 +1099,11 @@ namespace elna::boot } if (expression->type_decoration.empty()) { - add_error<field_not_found_error>(expression->field(), + add_error<field_not_found_error>(expression->field(), expression->base().type_decoration); + } + else + { + expression->type_decoration = qualify_member_type(expression->type_decoration, expression->base().type_decoration); } } @@ -1038,7 +1112,7 @@ namespace elna::boot { walking_visitor::visit(expression); - if (auto pointer = inner_aliased_type(expression->base().type_decoration).get<pointer_type>()) + if (auto pointer = resolve_underlying_type(expression->base().type_decoration).get<pointer_type>()) { expression->type_decoration = pointer->base; } @@ -1068,10 +1142,6 @@ namespace elna::boot { expression->type_decoration = variable_symbol->symbol; } - else if (auto constant_symbol = from_symbol_table->is_constant()) - { - expression->type_decoration = type_of_constant(constant_symbol->symbol); - } else if (auto procedure_symbol = from_symbol_table->is_procedure()) { expression->type_decoration = type(std::make_shared<procedure_type>(procedure_symbol->symbol)); @@ -1086,43 +1156,36 @@ namespace elna::boot void name_analysis_visitor::visit(literal<std::int32_t> *literal) { - this->current_literal = literal->value; literal->type_decoration = lookup_primitive_type("Int"); } void name_analysis_visitor::visit(literal<std::uint32_t> *literal) { - this->current_literal = literal->value; literal->type_decoration = lookup_primitive_type("Word"); } void name_analysis_visitor::visit(literal<double> *literal) { - this->current_literal = literal->value; literal->type_decoration = lookup_primitive_type("Float"); } void name_analysis_visitor::visit(literal<bool> *literal) { - this->current_literal = literal->value; literal->type_decoration = lookup_primitive_type("Bool"); } void name_analysis_visitor::visit(literal<unsigned char> *literal) { - this->current_literal = literal->value; literal->type_decoration = lookup_primitive_type("Char"); } void name_analysis_visitor::visit(literal<std::nullptr_t> *literal) { - this->current_literal = literal->value; literal->type_decoration = lookup_primitive_type("Pointer"); } void name_analysis_visitor::visit(literal<std::string> *literal) { - this->current_literal = literal->value; literal->type_decoration = lookup_primitive_type("String"); } @@ -1168,10 +1231,6 @@ namespace elna::boot { return; } - for (constant_declaration *const constant : declaration->body.value().constants) - { - constant->accept(this); - } for (variable_declaration *const variable : declaration->body.value().variables) { variable->accept(this); @@ -1189,79 +1248,4 @@ namespace elna::boot } } } - - void declaration_visitor::visit(constant_declaration *declaration) - { - if (declaration->identifier.exported()) - { - add_error<declaration_error>(declaration_error::kind::local_export, - declaration->identifier.id()); - } - } - - bool is_base_of(std::shared_ptr<record_type> base, std::shared_ptr<record_type> derived) - { - type current = derived->base; - - while (!current.empty()) - { - auto current_record = inner_aliased_type(current).get<record_type>(); - if (current_record == nullptr) - { - return false; - } - if (current_record == base) - { - return true; - } - current = current_record->base; - } - return false; - } - - bool are_compatible_pointers(type lhs_type, type rhs_type) - { - std::shared_ptr<primitive_type> lhs_primitive = lhs_type.get<primitive_type>(); - std::shared_ptr<primitive_type> rhs_primitive = rhs_type.get<primitive_type>(); - - bool lhs_is_primitive_pointer = lhs_primitive != nullptr && lhs_primitive->identifier == "Pointer"; - bool rhs_is_primitive_pointer = rhs_primitive != nullptr && rhs_primitive->identifier == "Pointer"; - - return (lhs_is_primitive_pointer && rhs_type.get<pointer_type>() != nullptr) - || (rhs_is_primitive_pointer && lhs_type.get<pointer_type>() != nullptr) - || (lhs_is_primitive_pointer && rhs_type.get<procedure_type>() != nullptr) - || (rhs_is_primitive_pointer && lhs_type.get<procedure_type>() != nullptr) - || (lhs_is_primitive_pointer && rhs_is_primitive_pointer); - } - - bool is_assignable_from(const type& assignee, const type& assignment) - { - type resolved_assignee = inner_aliased_type(assignee); - type resolved_assignment = inner_aliased_type(assignment); - - if (resolved_assignee == resolved_assignment) - { - return true; - } - // If the types do not match, only some pointers can be assigned. - if (are_compatible_pointers(resolved_assignee, resolved_assignment)) - { - return true; - } - std::shared_ptr<pointer_type> assignee_pointer = resolved_assignee.get<pointer_type>(); - std::shared_ptr<pointer_type> assignment_pointer = resolved_assignment.get<pointer_type>(); - - if (assignee_pointer == nullptr || assignment_pointer == nullptr) - { - return false; - } - // A pointer to a record can be assigned to a pointer to its base type. - type assignee_pointee = inner_aliased_type(assignee_pointer->base); - type assignment_pointee = inner_aliased_type(assignment_pointer->base); - std::shared_ptr<record_type> assignee_record = assignee_pointee.get<record_type>(); - std::shared_ptr<record_type> assignment_record = assignment_pointee.get<record_type>(); - - return assignee_record != nullptr && assignment_record != nullptr - && is_base_of(assignee_record, assignment_record); - } } diff --git a/boot/symbol.cc b/boot/symbol.cc index a3a36c1..9985489 100644 --- a/boot/symbol.cc +++ b/boot/symbol.cc @@ -43,6 +43,11 @@ namespace elna::boot { } + type::type(std::shared_ptr<constant_type> constant) + : tag(type_tag::constant), constant(constant) + { + } + type::type(std::shared_ptr<array_type> array) : tag(type_tag::array), array(array) { @@ -76,6 +81,9 @@ namespace elna::boot case type_tag::pointer: new (&pointer) std::shared_ptr<pointer_type>(other.pointer); break; + case type_tag::constant: + new (&constant) std::shared_ptr<constant_type>(other.constant); + break; case type_tag::array: new (&array) std::shared_ptr<array_type>(other.array); break; @@ -112,6 +120,9 @@ namespace elna::boot case type_tag::pointer: new (&pointer) std::shared_ptr<pointer_type>(std::move(other.pointer)); break; + case type_tag::constant: + new (&constant) std::shared_ptr<constant_type>(std::move(other.constant)); + break; case type_tag::array: new (&array) std::shared_ptr<array_type>(std::move(other.array)); break; @@ -164,6 +175,9 @@ namespace elna::boot case type_tag::pointer: this->pointer.~shared_ptr<pointer_type>(); break; + case type_tag::constant: + this->constant.~shared_ptr<constant_type>(); + break; case type_tag::array: this->array.~shared_ptr<array_type>(); break; @@ -207,6 +221,12 @@ namespace elna::boot } template<> + std::shared_ptr<constant_type> type::get<constant_type>() const + { + return tag == type_tag::constant ? this->constant : nullptr; + } + + template<> std::shared_ptr<procedure_type> type::get<procedure_type>() const { return tag == type_tag::procedure ? this->procedure : nullptr; @@ -225,8 +245,8 @@ namespace elna::boot bool type::operator==(const type& other) const { - type resolved_this = inner_aliased_type(*this); - type resolved_that = inner_aliased_type(other); + type resolved_this = resolve_aliases(*this); + type resolved_that = resolve_aliases(other); if (auto left_record = resolved_this.get<record_type>()) { @@ -248,6 +268,12 @@ namespace elna::boot return right_pointer != nullptr && left_pointer->base == right_pointer->base; } + if (auto left_const = resolved_this.get<constant_type>()) + { + auto right_const = resolved_that.get<constant_type>(); + + return right_const != nullptr && left_const->unqualified == right_const->unqualified; + } if (auto left_array = resolved_this.get<array_type>()) { auto right_array = resolved_that.get<array_type>(); @@ -282,6 +308,8 @@ namespace elna::boot return primitive->identifier; case type_tag::pointer: return "^" + pointer->base.to_string(); + case type_tag::constant: + return "const " + constant->unqualified.to_string(); case type_tag::array: return "[" + std::to_string(array->size) + "]" + array->base.to_string(); case type_tag::record: @@ -328,6 +356,11 @@ namespace elna::boot { } + constant_type::constant_type(type unqualified) + : unqualified(unqualified) + { + } + array_type::array_type(type base, std::uint64_t size) : base(base), size(size) { @@ -367,11 +400,6 @@ namespace elna::boot return nullptr; } - std::shared_ptr<constant_info> info::is_constant() - { - return nullptr; - } - std::shared_ptr<variable_info> info::is_variable() { return nullptr; @@ -403,16 +431,6 @@ namespace elna::boot return this->scope == nullptr; } - constant_info::constant_info(const variant& symbol) - : symbol(symbol) - { - } - - std::shared_ptr<constant_info> constant_info::is_constant() - { - return std::static_pointer_cast<constant_info>(shared_from_this()); - } - variable_info::variable_info(const type symbol, bool is_extern) : symbol(symbol), is_extern(is_extern) { @@ -524,20 +542,47 @@ namespace elna::boot return m_exported; } - type inner_aliased_type(std::shared_ptr<alias_type> alias) + type resolve_underlying_type(std::shared_ptr<alias_type> alias) { - return inner_aliased_type(alias->reference); + return resolve_underlying_type(alias->reference); } - type inner_aliased_type(const type& alias) + type resolve_underlying_type(const type& alias) { - if (auto aliased = alias.get<alias_type>()) + type resolved_alias = resolve_aliases(alias); + + if (auto qualified = resolved_alias.get<constant_type>()) { - return inner_aliased_type(aliased); + return resolve_underlying_type(qualified->unqualified); } else { - return alias; + return resolved_alias; + } + } + + type resolve_aliases(const type& checked) + { + if (auto alias = checked.get<alias_type>()) + { + return resolve_aliases(alias->reference); + } + return checked; + } + + bool is_primitive_type(const type& checked, const std::string& name) + { + if (auto primitive_checked = checked.get<primitive_type>()) + { + return primitive_checked->identifier == name; } + return false; + } + + bool is_any_pointer_type(const type& checked) + { + return checked.get<pointer_type>() != nullptr + || checked.get<procedure_type>() != nullptr + || is_primitive_type(checked, "Pointer"); } } diff --git a/gcc/gcc/elna-builtins.cc b/gcc/gcc/elna-builtins.cc index 9e331cf..3c424f8 100644 --- a/gcc/gcc/elna-builtins.cc +++ b/gcc/gcc/elna-builtins.cc @@ -160,6 +160,10 @@ namespace elna::gcc return build_pointer_type(procedure); } + else if (auto reference = type.get<boot::constant_type>()) + { + return get_inner_alias(reference->unqualified, symbols); + } else if (auto reference = type.get<boot::alias_type>()) { return TREE_TYPE(handle_symbol(reference->name, reference, symbols)); diff --git a/gcc/gcc/elna-generic.cc b/gcc/gcc/elna-generic.cc index 4067bb6..b849715 100644 --- a/gcc/gcc/elna-generic.cc +++ b/gcc/gcc/elna-generic.cc @@ -228,10 +228,6 @@ namespace elna::gcc { declaration->accept(this); } - for (boot::constant_declaration *const constant : unit->constants) - { - constant->accept(this); - } for (boot::variable_declaration *const variable : unit->variables) { variable->accept(this); @@ -309,10 +305,6 @@ namespace elna::gcc { this->symbols->enter(IDENTIFIER_POINTER(DECL_NAME(argument_chain)), argument_chain); } - for (boot::constant_declaration *const constant : declaration->body.value().constants) - { - constant->accept(this); - } for (boot::variable_declaration *const variable : declaration->body.value().variables) { variable->accept(this); @@ -704,41 +696,6 @@ namespace elna::gcc } } - void generic_visitor::visit(boot::constant_declaration *declaration) - { - location_t definition_location = get_location(&declaration->position()); - declaration->initializer().accept(this); - - if (assert_constant(definition_location)) - { - this->current_expression = fold_init(this->current_expression); - } - else - { - this->current_expression = NULL_TREE; - return; - } - tree definition_tree = build_decl(definition_location, CONST_DECL, - get_identifier(declaration->identifier.name().c_str()), TREE_TYPE(this->current_expression)); - auto result = this->symbols->enter(declaration->identifier.name(), definition_tree); - - if (result) - { - DECL_INITIAL(definition_tree) = this->current_expression; - TREE_CONSTANT(definition_tree) = 1; - TREE_READONLY(definition_tree) = 1; - TREE_PUBLIC(definition_tree) = declaration->identifier.exported(); - - if (!lang_hooks.decls.global_bindings_p()) - { - auto declaration_statement = build1_loc(definition_location, DECL_EXPR, - void_type_node, definition_tree); - append_statement(declaration_statement); - } - } - this->current_expression = NULL_TREE; - } - void generic_visitor::visit(boot::variable_declaration *declaration) { for (const auto& variable_identifier : declaration->identifiers) @@ -762,6 +719,14 @@ namespace elna::gcc { DECL_INITIAL(declaration_tree) = elna_pointer_nil_node; } + { + auto variable_symbol = this->bag.lookup(variable_identifier.name())->is_variable(); + + if (variable_symbol != nullptr && variable_symbol->symbol.get<boot::constant_type>() != nullptr) + { + TREE_READONLY(declaration_tree) = 1; + } + } this->current_expression = NULL_TREE; if (lang_hooks.decls.global_bindings_p()) diff --git a/gcc/testlib/elna-dg.exp b/gcc/testlib/elna-dg.exp index ddebf58..5142884 100644 --- a/gcc/testlib/elna-dg.exp +++ b/gcc/testlib/elna-dg.exp @@ -35,6 +35,47 @@ proc elna-dg-prune { system text } { # Utility routines. # +# Escapes a directive argument so that it reaches dejagnu intact. +# +# dg.exp evaluates each extracted directive as a Tcl script +# ("catch $op"), which performs one round of backslash, command and +# variable substitution inside the double-quoted argument. Quoting the +# affected characters here means the argument dejagnu receives is +# exactly what the test author wrote, so @Error messages keep their +# regular expression semantics: "\[2\]" matches literal brackets and +# "[2]" stays a character class. +# +proc elna-escape-directive { text } { + return [string map [list \ + "\\" "\\\\" \ + "\[" "\\\[" \ + "\]" "\\\]" \ + "\$" "\\\$" \ + "\"" "\\\""] $text] +} + +# +# Replaces an elna-native directive in the line with its dg-* equivalent, +# escaping the directive argument for dejagnu's Tcl evaluation. +# +# line_var - name of the variable holding the line in the caller. +# directive - elna directive name, e.g. @Error. +# dg_name - dejagnu directive name, e.g. dg-error. +# +proc elna-convert-directive { line_var directive dg_name } { + upvar 1 $line_var line + + if { [regexp -indices "\\(\\*\\s*$directive\\s+(.*?)\\s*\\*\\)" $line whole argument] } { + set escaped [elna-escape-directive \ + [string range $line [lindex $argument 0] [lindex $argument 1]]] + set prefix [string range $line 0 [expr {[lindex $whole 0] - 1}]] + set suffix [string range $line [expr {[lindex $whole 1] + 1}] end] + + set line "${prefix}(* { $dg_name \"$escaped\" } *)$suffix" + } +} + +# # This procedure copies a test file from the source tree to the # build directory while rewriting elna-native directives to dejagnu # dg-* equivalents. @@ -60,8 +101,8 @@ proc elna-convert-test { base test } { # Reads the source test file line by line and replace directives with # Elna equivalents using a regular expression. while { [gets $fin line] >= 0 } { - regsub -all {\(\*\s*@Error\s+(.*?)\s*\*\)} $line {(* { dg-error "\1" } *)} line - regsub -all {\(\*\s*@Flags\s+(.*?)\s*\*\)} $line {(* { dg-additional-options "\1" } *)} line + elna-convert-directive line @Error dg-error + elna-convert-directive line @Flags dg-additional-options puts $fout $line } diff --git a/include/elna/boot/ast.h b/include/elna/boot/ast.h index b6aad70..42e7666 100644 --- a/include/elna/boot/ast.h +++ b/include/elna/boot/ast.h @@ -55,7 +55,6 @@ namespace elna::boot }; class variable_declaration; - class constant_declaration; class procedure_declaration; class type_declaration; class procedure_call; @@ -74,6 +73,7 @@ namespace elna::boot class type_expression; class array_type_expression; class pointer_type_expression; + class constant_type_expression; class record_type_expression; class procedure_type_expression; class enumeration_type_expression; @@ -94,7 +94,6 @@ namespace elna::boot struct parser_visitor { virtual void visit(variable_declaration *) = 0; - virtual void visit(constant_declaration *) = 0; virtual void visit(procedure_declaration *) = 0; virtual void visit(type_declaration *) = 0; virtual void visit(procedure_call *) = 0; @@ -114,6 +113,7 @@ namespace elna::boot virtual void visit(unary_expression *) = 0; virtual void visit(array_type_expression *) = 0; virtual void visit(pointer_type_expression *) = 0; + virtual void visit(constant_type_expression *) = 0; virtual void visit(record_type_expression *) = 0; virtual void visit(procedure_type_expression *) = 0; virtual void visit(enumeration_type_expression *) = 0; @@ -138,13 +138,13 @@ namespace elna::boot 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(constant_declaration *) override; [[noreturn]] virtual void visit(procedure_declaration *) override; [[noreturn]] virtual void visit(assign_statement *) override; [[noreturn]] virtual void visit(if_statement *) override; @@ -182,13 +182,13 @@ namespace elna::boot 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(constant_declaration *) override; virtual void visit(procedure_declaration *) override; virtual void visit(assign_statement *) override; virtual void visit(if_statement *) override; @@ -280,6 +280,7 @@ namespace elna::boot virtual named_expression *is_named(); virtual array_type_expression *is_array(); virtual pointer_type_expression *is_pointer(); + virtual constant_type_expression *is_constant(); virtual record_type_expression *is_record(); virtual procedure_type_expression *is_procedure(); virtual enumeration_type_expression *is_enumeration(); @@ -316,6 +317,20 @@ namespace elna::boot type_expression& base(); }; + class constant_type_expression : public type_expression + { + type_expression *m_base; + + public: + constant_type_expression(const source_position position, type_expression *base); + ~constant_type_expression() override; + + void accept(parser_visitor *visitor) override; + constant_type_expression *is_constant() override; + + type_expression& base(); + }; + using field_declaration = std::pair<std::vector<identifier>, std::shared_ptr<type_expression>>; class record_type_expression : public type_expression @@ -430,23 +445,6 @@ namespace elna::boot }; /** - * Constant definition. - */ - class constant_declaration : public declaration - { - expression *m_initializer; - - public: - constant_declaration(const source_position position, identifier_definition identifier, - expression *initializer); - void accept(parser_visitor *visitor) override; - - expression& initializer(); - - virtual ~constant_declaration() override; - }; - - /** * Procedure type. */ class procedure_type_expression : public type_expression @@ -467,15 +465,13 @@ namespace elna::boot struct procedure_body { - const std::vector<constant_declaration *> constants; const std::vector<variable_declaration *> variables; const std::vector<statement *> entry_point; expression *const return_expression{ nullptr }; - procedure_body(std::vector<constant_declaration *>&& constants, - std::vector<variable_declaration *>&& variables, + procedure_body(std::vector<variable_declaration *>&& variables, std::vector<statement *>&& entry_point, - expression *return_expr = nullptr); + expression *return_expression = nullptr); procedure_body(const procedure_body&) = delete; procedure_body(procedure_body&& that); @@ -773,7 +769,6 @@ namespace elna::boot unit(const source_position position); unit(const source_position position, std::vector<import_declaration *>&& imports, - std::vector<constant_declaration *>&& constants, std::vector<type_declaration *>&& types, std::vector<variable_declaration *>&& variables, std::vector<procedure_declaration *>&& procedures, diff --git a/include/elna/boot/semantic.h b/include/elna/boot/semantic.h index 0f8f6c7..3d2de10 100644 --- a/include/elna/boot/semantic.h +++ b/include/elna/boot/semantic.h @@ -85,6 +85,19 @@ namespace elna::boot }; /** + * Attempted to assign a value whose type contains constant members. + */ + class constant_assignment_error : public error + { + type assignee; + + public: + constant_assignment_error(const source_position position, type assignee); + + std::string what() const override; + }; + + /** * Attempted to access a field that does not exist on the given type. */ class field_not_found_error : public error @@ -199,8 +212,20 @@ namespace elna::boot symbol_bag bag; std::shared_ptr<procedure_info> current_procedure; - bool check_unresolved_symbol(std::shared_ptr<alias_type> alias, + /* + * Whether an expression of type assignment can be assigned to a variable + * of type assignee. + */ + static bool is_assignable_from(const type& assignee, const type& assignment); + /* + * Checks whether derived has base in its parent chain. + * base should not be null, derived can be null. + */ + static bool is_base_of(const std::shared_ptr<record_type>& base, + const std::shared_ptr<record_type>& derived); + static bool check_unresolved_symbol(std::shared_ptr<alias_type> alias, std::vector<std::string>& path); + public: explicit type_analysis_visitor(symbol_bag bag); @@ -231,7 +256,6 @@ namespace elna::boot class name_analysis_visitor final : public walking_visitor, public error_container { type current_type; - constant_info::variant current_literal; symbol_bag bag; @@ -244,7 +268,6 @@ namespace elna::boot const bool is_extern, const source_position position); type lookup_primitive_type(const std::string& name); - type type_of_constant(const constant_info::variant& value); type lookup_field(const type& composite_type, const std::string& field_name); public: @@ -252,6 +275,7 @@ namespace elna::boot void visit(array_type_expression *expression) override; void visit(pointer_type_expression *expression) override; + void visit(constant_type_expression *expression) override; void visit(type_declaration *declaration) override; void visit(record_type_expression *expression) override; void visit(record_constructor_expression *expression) override; @@ -260,7 +284,6 @@ namespace elna::boot void visit(enumeration_type_expression *expression) override; void visit(variable_declaration *declaration) override; - void visit(constant_declaration *declaration) override; void visit(procedure_declaration *declaration) override; void visit(procedure_call *call) override; @@ -297,16 +320,5 @@ namespace elna::boot void visit(type_declaration *declaration) override; void visit(procedure_declaration *declaration) override; void visit(variable_declaration *declaration) override; - void visit(constant_declaration *declaration) override; }; - - /** - * Whether an expression of type \a assignment can be assigned to a variable - * of type \a assignee. - * - * \param assignee Assignee. - * \param assignment Assignment. - * \return Whether the assignment can be performed. - */ - bool is_assignable_from(const type& assignee, const type& assignment); } diff --git a/include/elna/boot/symbol.h b/include/elna/boot/symbol.h index ec5a051..6884dd7 100644 --- a/include/elna/boot/symbol.h +++ b/include/elna/boot/symbol.h @@ -32,6 +32,7 @@ namespace elna::boot class primitive_type; class record_type; class pointer_type; + class constant_type; class array_type; class procedure_type; class enumeration_type; @@ -45,6 +46,7 @@ namespace elna::boot primitive, record, pointer, + constant, array, procedure, enumeration @@ -56,6 +58,7 @@ namespace elna::boot std::shared_ptr<primitive_type> primitive; std::shared_ptr<record_type> record; std::shared_ptr<pointer_type> pointer; + std::shared_ptr<constant_type> constant; std::shared_ptr<array_type> array; std::shared_ptr<procedure_type> procedure; std::shared_ptr<enumeration_type> enumeration; @@ -70,6 +73,7 @@ namespace elna::boot explicit type(std::shared_ptr<primitive_type> primitive); explicit type(std::shared_ptr<record_type> record); explicit type(std::shared_ptr<pointer_type> pointer); + explicit type(std::shared_ptr<constant_type> constant); explicit type(std::shared_ptr<array_type> array); explicit type(std::shared_ptr<procedure_type> procedure); explicit type(std::shared_ptr<enumeration_type> enumeration); @@ -112,6 +116,13 @@ namespace elna::boot explicit pointer_type(type base); }; + struct constant_type + { + const type unqualified; + + explicit constant_type(type unqualified); + }; + struct array_type { const type base; @@ -156,7 +167,6 @@ namespace elna::boot class type_info; class procedure_info; - class constant_info; class variable_info; class info : public std::enable_shared_from_this<info> @@ -169,7 +179,6 @@ namespace elna::boot virtual std::shared_ptr<type_info> is_type(); virtual std::shared_ptr<procedure_info> is_procedure(); - virtual std::shared_ptr<constant_info> is_constant(); virtual std::shared_ptr<variable_info> is_variable(); }; @@ -332,18 +341,6 @@ namespace elna::boot bool is_extern() const; }; - class constant_info : public info - { - public: - using variant = typename - std::variant<std::int32_t, std::uint32_t, double, bool, unsigned char, std::nullptr_t, std::string>; - - const variant symbol; - - explicit constant_info(const variant& symbol); - std::shared_ptr<constant_info> is_constant() override; - }; - /** * Variable symbol information. */ @@ -467,13 +464,46 @@ namespace elna::boot }; /** - * If a type is a declared name for another type, look up recursively - * the declared type. If the given type is not an alias, then this function - * returns its argument. + * Resolves alias chains and type qualifiers until the underlying type is + * reached. If the given type is neither an alias nor qualified, it is + * returned as is. + * + * \param alias The type to resolve. + * \return The underlying, unqualified type. + */ + type resolve_underlying_type(const type& alias); + + /** + * \overload + */ + type resolve_underlying_type(std::shared_ptr<alias_type> alias); + + /** + * Resolves an alias chain until the underlying type or a qualified type is + * reached. + * + * \param checked The type to resolve. + * \return The first non-alias type in the chain. + */ + type resolve_aliases(const type& checked); + + /** + * Checks whether the given type is the built-in type \a name. + * + * \param checked The type to check. + * \param name The name of the primitive type to compare against. + * \return Whether the type is the primitive type with the given name. + */ + bool is_primitive_type(const type& checked, const std::string& name); + + /** + * Checks whether the given type is a pointer type. + * + * A pointer type is considered to be a variable pointer, a procedure + * pointer, or a built-in Pointer. * - * \param alias The type to lookup the innermost declaration for. - * \return Innermost type declaration. + * \param checked The type to check. + * \return Whether the type is a pointer type. */ - type inner_aliased_type(const type& alias); - type inner_aliased_type(std::shared_ptr<alias_type> alias); + bool is_any_pointer_type(const type& checked); } diff --git a/include/elna/gcc/elna-generic.h b/include/elna/gcc/elna-generic.h index e0f20f3..a1689be 100644 --- a/include/elna/gcc/elna-generic.h +++ b/include/elna/gcc/elna-generic.h @@ -76,7 +76,6 @@ namespace elna::gcc void visit(boot::literal<std::string> *string) override; void visit(boot::binary_expression *expression) override; void visit(boot::unary_expression *expression) override; - void visit(boot::constant_declaration *declaration) override; void visit(boot::variable_declaration *declaration) override; void visit(boot::named_expression *expression) override; void visit(boot::array_access_expression *expression) override; diff --git a/source/lexer.elna b/source/lexer.elna index 63ca3d3..c221f07 100644 --- a/source/lexer.elna +++ b/source/lexer.elna @@ -4,9 +4,6 @@ import cstdio, common, cstdlib -const - CHUNK_SIZE := 85536u - type ElnaLexerState = ( start, diff --git a/testsuite/compilable/float_literals.elna b/testsuite/compilable/float_literals.elna index ed23989..77af6b1 100644 --- a/testsuite/compilable/float_literals.elna +++ b/testsuite/compilable/float_literals.elna @@ -1,9 +1,9 @@ proc f() -const - x := 3.14 - y := 1e10 - z := 4.567e8 - t := 2.5E-3 +var + x: const Float := 3.14 + y: const Float := 1e10 + z: const Float := 4.567e8 + t: const Float := 2.5E-3 return end. diff --git a/testsuite/compilable/pointer_const_conversion.elna b/testsuite/compilable/pointer_const_conversion.elna new file mode 100644 index 0000000..fd8e097 --- /dev/null +++ b/testsuite/compilable/pointer_const_conversion.elna @@ -0,0 +1,7 @@ +var + x: Int + p: ^const Int + +begin + p := @x +end. diff --git a/testsuite/compilable/take_const_address.elna b/testsuite/compilable/take_const_address.elna new file mode 100644 index 0000000..54a2992 --- /dev/null +++ b/testsuite/compilable/take_const_address.elna @@ -0,0 +1,7 @@ +var + x: ^const Int + y: const Int + +begin + x := @y +end. diff --git a/testsuite/fail_compilation/assign_const_array_pointer.elna b/testsuite/fail_compilation/assign_const_array_pointer.elna new file mode 100644 index 0000000..32dc66d --- /dev/null +++ b/testsuite/fail_compilation/assign_const_array_pointer.elna @@ -0,0 +1,9 @@ +proc f() +var + p: ^[2]Int + q: ^const [2]Int +begin + p := q (* @Error Expected type '\^\[2\]Int', but got '\^const \[2\]Int' *) +return + +end. diff --git a/testsuite/fail_compilation/assign_const_member.elna b/testsuite/fail_compilation/assign_const_member.elna new file mode 100644 index 0000000..8aecb01 --- /dev/null +++ b/testsuite/fail_compilation/assign_const_member.elna @@ -0,0 +1,14 @@ +type + R = record + x: const Int + end + +proc f() +var + r1: R := R{ x: 5 } + r2: R := R{ x: 5 } +begin + r1 := r2 (* @Error Cannot assign to a value of type 'R', because it is constant or contains constant members *) +return + +end. diff --git a/testsuite/fail_compilation/assign_const_primitive.elna b/testsuite/fail_compilation/assign_const_primitive.elna new file mode 100644 index 0000000..34b095b --- /dev/null +++ b/testsuite/fail_compilation/assign_const_primitive.elna @@ -0,0 +1,8 @@ +proc f() +var + x: const Int +begin + x := 5 (* @Error Cannot assign to a value of type 'const Int', because it is constant or contains constant members *) +return + +end. diff --git a/testsuite/fail_compilation/assign_const_record_pointer.elna b/testsuite/fail_compilation/assign_const_record_pointer.elna new file mode 100644 index 0000000..5e6f3df --- /dev/null +++ b/testsuite/fail_compilation/assign_const_record_pointer.elna @@ -0,0 +1,17 @@ +type + B = record + x: Int + end + D = record(B) + y: Int + end + +proc f() +var + b: ^B + d: ^const D +begin + b := d (* @Error Expected type '\^B', but got '\^const D' *) +return + +end. diff --git a/testsuite/fail_compilation/assign_deep_const_pointer.elna b/testsuite/fail_compilation/assign_deep_const_pointer.elna new file mode 100644 index 0000000..7ed3840 --- /dev/null +++ b/testsuite/fail_compilation/assign_deep_const_pointer.elna @@ -0,0 +1,9 @@ +proc f() +var + p: ^^const Int + q: ^^Int +begin + p := q (* @Error Expected type '\^\^const Int', but got '\^\^Int' *) +return + +end. diff --git a/testsuite/fail_compilation/assign_element_of_const.elna b/testsuite/fail_compilation/assign_element_of_const.elna new file mode 100644 index 0000000..9afd520 --- /dev/null +++ b/testsuite/fail_compilation/assign_element_of_const.elna @@ -0,0 +1,8 @@ +proc f() +var + a: const [2]Int +begin + a[1] := 6 (* @Error Cannot assign to a value of type 'const Int', because it is constant or contains constant members *) +return + +end. diff --git a/testsuite/fail_compilation/assign_member_of_const.elna b/testsuite/fail_compilation/assign_member_of_const.elna new file mode 100644 index 0000000..fc945bb --- /dev/null +++ b/testsuite/fail_compilation/assign_member_of_const.elna @@ -0,0 +1,13 @@ +type + R = record + x: Int + end + +proc f() +var + r: const R := R{ x: 5 } +begin + r.x := 6 (* @Error Cannot assign to a value of type 'const Int', because it is constant or contains constant members *) +return + +end. diff --git a/testsuite/fail_compilation/local_const_exported.elna b/testsuite/fail_compilation/local_const_exported.elna deleted file mode 100644 index 1c6c728..0000000 --- a/testsuite/fail_compilation/local_const_exported.elna +++ /dev/null @@ -1,6 +0,0 @@ -proc test_local_export() -const - c* := 42 (* @Error Local symbol 'c' cannot be exported *) -return - -end. diff --git a/testsuite/runnable/const_copy.elna b/testsuite/runnable/const_copy.elna new file mode 100644 index 0000000..5982149 --- /dev/null +++ b/testsuite/runnable/const_copy.elna @@ -0,0 +1,12 @@ +proc f() +var + x: const Int := 5 + y: Int +begin + y := x; + assert(y = 5) +return + +begin + f() +end. diff --git a/testsuite/runnable/const_initialization.elna b/testsuite/runnable/const_initialization.elna new file mode 100644 index 0000000..7f922ff --- /dev/null +++ b/testsuite/runnable/const_initialization.elna @@ -0,0 +1,10 @@ +proc f() +var + x: const Int := 5 +begin + assert(x = 5) +return + +begin + f() +end. |