Replace noreturn type with an attribute

6 files changed, 53 insertions, 108 deletions

diff --git a/boot/ast.cc b/boot/ast.cc
index 87d6313..bdc9089 100644
--- a/boot/ast.cc
+++ b/boot/ast.cc
@@ -237,9 +237,9 @@ namespace elna::boot
         {
             parameter.second->accept(this);
         }
-        if (declaration->heading().return_type.proper_type != nullptr)
+        if (declaration->heading().return_type != nullptr)
         {
-            declaration->heading().return_type.proper_type->accept(this);
+            declaration->heading().return_type->accept(this);
         }
         if (declaration->body.has_value())
         {
@@ -394,9 +394,9 @@ namespace elna::boot
         {
             field.second->accept(this);
         }
-        if (expression->return_type.proper_type != nullptr)
+        if (expression->return_type != nullptr)
         {
-            expression->return_type.proper_type->accept(this);
+            expression->return_type->accept(this);
         }
     }
 
@@ -949,14 +949,14 @@ namespace elna::boot
     }
 
     procedure_type_expression::procedure_type_expression(const source_position position,
-            std::vector<field_declaration>&& parameters, return_t return_type)
+            std::vector<field_declaration>&& parameters, type_expression *return_type)
         : node(position), return_type(return_type), parameters(std::move(parameters))
     {
     }
 
     procedure_type_expression::~procedure_type_expression()
     {
-        delete return_type.proper_type;
+        delete return_type;
     }
 
     void procedure_type_expression::accept(parser_visitor *visitor)
diff --git a/boot/lexer.ll b/boot/lexer.ll
index 6fa1904..4452956 100644
--- a/boot/lexer.ll
+++ b/boot/lexer.ll
@@ -476,9 +476,6 @@ module {
 @ {
     return yy::parser::make_AT(this->location);
 }
-! {
-    return yy::parser::make_EXCLAMATION(this->location);
-}
 -> {
     return yy::parser::make_ARROW(this->location);
 }
diff --git a/boot/name_analysis.cc b/boot/name_analysis.cc
index 20f08ee..1a87927 100644
--- a/boot/name_analysis.cc
+++ b/boot/name_analysis.cc
@@ -90,6 +90,8 @@ namespace elna::boot
                 return "Attribute '" + this->name + "' takes no arguments";
             case missing_parameter:
                 return "Attribute '" + this->name + "' requires at least one parameter";
+            case return_type:
+                return "Attribute '" + this->name + "' cannot be used with a return type";
             default:
                 __builtin_unreachable();
         }
@@ -317,53 +319,6 @@ namespace elna::boot
     {
     }
 
-    procedure_type::return_t resolving_visitor::build_return_type(
-            const procedure_type_expression::return_t& return_type)
-    {
-        if (return_type.no_return)
-        {
-            return procedure_type::return_t(std::monostate{});
-        }
-        else if (return_type.proper_type != nullptr)
-        {
-            return procedure_type::return_t(resolve_type(*return_type.proper_type));
-        }
-        else
-        {
-            return procedure_type::return_t();
-        }
-    }
-
-    std::pair<procedure_type, std::vector<std::string>> resolving_visitor::build_procedure(
-            procedure_type_expression& expression, const bool variadic_supported)
-    {
-        const procedure_type::return_t result_return = build_return_type(expression.return_type);
-        std::pair<procedure_type, std::vector<std::string>> result_type{
-            procedure_type(result_return), std::vector<std::string>()
-        };
-        for (const auto& [parameter_names, parameters_type] : expression.parameters)
-        {
-            const type parameter_type = resolve_type(*parameters_type);
-
-            for (const auto& parameter_name : parameter_names)
-            {
-                evaluate_attributes<>(parameter_name.attributes);
-                result_type.first.parameters.push_back(parameter_type);
-                result_type.second.push_back(parameter_name.name());
-            }
-        }
-        result_type.first.variadic = variadic_supported
-            ? evaluate_attributes<attribute_kind::varargs>(expression.attributes).variadic
-            : evaluate_attributes<>(expression.attributes).variadic;
-
-        if (result_type.first.variadic && result_type.first.parameters.empty())
-        {
-            add_error<attribute_error>(expression.position(), "varargs",
-                    attribute_error::kind::missing_parameter);
-        }
-        return result_type;
-    }
-
     std::optional<attribute_kind> resolving_visitor::parse_attribute(const std::string& name)
     {
         if (name == "aligned")
@@ -374,6 +329,10 @@ namespace elna::boot
         {
             return attribute_kind::varargs;
         }
+        if (name == "noreturn")
+        {
+            return attribute_kind::noreturn;
+        }
         return std::nullopt;
     }
 
@@ -676,16 +635,15 @@ namespace elna::boot
         ordered_map<field_origin> field_names;
         collect_field_names(result_type->base, field_names);
         result_type->fields = build_composite_type(expression->fields, field_names, type(result_type));
-        result_type->alignment =
-            evaluate_attributes<attribute_kind::aligned>(expression->attributes).alignment;
+        result_type->alignment = evaluate_attributes<attribute_kind::aligned>(expression->attributes).alignment;
 
         this->current_type = type(result_type);
     }
 
     void resolving_visitor::visit(procedure_type_expression *expression)
     {
-        std::shared_ptr<procedure_type> const result_type =
-            std::make_shared<procedure_type>(std::move(build_procedure(*expression, true).first));
+        const std::shared_ptr<procedure_type> result_type =
+            std::make_shared<procedure_type>(build_procedure<attribute_kind::varargs>(*expression).heading);
 
         this->current_type = type(result_type);
     }
@@ -851,7 +809,7 @@ namespace elna::boot
         call->callable().accept(this);
         if (const auto procedure = call->callable().type_decoration.get<procedure_type>())
         {
-            call->type_decoration = procedure->return_type.proper_type;
+            call->type_decoration = procedure->return_type;
         }
         visit_all(this, call->arguments);
         this->current_type = type();
@@ -1290,10 +1248,10 @@ namespace elna::boot
                     return false;
                 }
             }
-            if (!link->return_type.proper_type.empty())
+            if (!link->return_type.empty())
             {
                 alias_path.resize(saved_path);
-                return find_alias_cycle(being_resolved, link->return_type.proper_type, alias_path, state);
+                return find_alias_cycle(being_resolved, link->return_type, alias_path, state);
             }
             return true;
         }
@@ -1328,8 +1286,7 @@ namespace elna::boot
         if (unit->entry_point.has_value())
         {
             const type word8_primitive = lookup_primitive_type("Word8");
-            const procedure_type::return_t result_return = procedure_type::return_t(word8_primitive);
-            auto heading = procedure_type(result_return);
+            auto heading = procedure_type(word8_primitive);
             std::shared_ptr<procedure_info> info;
 
             if (unit->parameters.size() > 1)
@@ -1451,8 +1408,9 @@ namespace elna::boot
         // is why the body sees them too.
         const std::shared_ptr<symbol_table> scope = this->bag.enter();
         const std::vector<type> type_parameters = enter_parameters(declaration->parameters);
-        auto [heading, parameter_names] =
-            build_procedure(declaration->heading(), !declaration->body.has_value());
+        auto [heading, parameter_names, noreturn] = !declaration->body.has_value()
+            ? build_procedure<attribute_kind::varargs, attribute_kind::noreturn>(declaration->heading())
+            : build_procedure<attribute_kind::noreturn>(declaration->heading());
         std::shared_ptr<procedure_info> info_object;
 
         if (declaration->body.has_value())
@@ -1480,6 +1438,8 @@ namespace elna::boot
         info_object->exported = declaration->identifier.exported();
         info_object->position.emplace(declaration->position());
         info_object->file = this->module_file;
+        info_object->noreturn = noreturn;
+
         if (!this->bag.enter(declaration->identifier.name(), info_object))
         {
             const std::shared_ptr<info> original = this->bag.lookup(declaration->identifier.name());
diff --git a/boot/parser.yy b/boot/parser.yy
index cc73aef..04c07a8 100644
--- a/boot/parser.yy
+++ b/boot/parser.yy
@@ -91,9 +91,7 @@ along with GCC; see the file COPYING3.  If not see
 %token <bool> BOOLEAN
 %token LEFT_PAREN "(" RIGHT_PAREN ")" LEFT_SQUARE "[" RIGHT_SQUARE "]"
     LEFT_BRACE "{" RIGHT_BRACE "}" GENERIC_OPEN "#[" ATTRIBUTE_OPEN "#{"
-%token ASSIGNMENT ":="
-    EXCLAMATION "!" ARROW "->"
-    AT "@" HAT "^"
+%token ASSIGNMENT ":=" ARROW "->" AT "@" HAT "^"
     COLON ":" SEMICOLON ";" DOT "." COMMA ","
 %token PROGRAM "program" MODULE "module"
     CAST "cast"
@@ -135,7 +133,7 @@ along with GCC; see the file COPYING3.  If not see
 %type <std::vector<elna::boot::switch_case>> switch_cases;
 %type <elna::boot::variable_declaration *> variable_declaration;
 %type <std::vector<elna::boot::variable_declaration *>> variable_declarations;
-%type <elna::boot::type_expression *> type_expression;
+%type <elna::boot::type_expression *> type_expression return_declaration;
 %type <std::vector<elna::boot::type_expression *>> type_expressions;
 %type <elna::boot::expression *> expression operand simple_expression procedure_return unary_expression;
 %type <elna::boot::binary_expression *> binary_expression;
@@ -146,7 +144,6 @@ along with GCC; see the file COPYING3.  If not see
 %type <std::vector<elna::boot::statement *>> statements statement_part optional_begin_statements;
 %type <elna::boot::procedure_declaration *> procedure_declaration;
 %type <elna::boot::procedure_type_expression *> procedure_heading;
-%type <elna::boot::procedure_type_expression::return_t> return_declaration;
 %type <elna::boot::type_declaration *> type_declaration;
 %type <std::vector<elna::boot::declaration *>> type_declarations sections section;
 %type <std::pair<std::vector<elna::boot::import_declaration *>, std::vector<elna::boot::declaration *>>>
@@ -274,8 +271,7 @@ identifier_definitions:
     | attributed_identifier { $$.emplace_back(std::move(*$1)); }
 return_declaration:
     %empty {}
-    | "->" "!" { $$ = boot::procedure_type_expression::return_t(std::monostate{}); }
-    | "->" type_expression { $$ = boot::procedure_type_expression::return_t($2); }
+    | "->" type_expression { $$ = $2; }
 procedure_heading:
     "(" field_declarations ")" attributes return_declaration
         {
diff --git a/boot/symbol.cc b/boot/symbol.cc
index 54cb595..2293275 100644
--- a/boot/symbol.cc
+++ b/boot/symbol.cc
@@ -199,13 +199,9 @@ namespace elna::boot
                 {
                     result += " #{varargs}";
                 }
-                if (payload->return_type.no_return)
+                else if (!payload->return_type.empty())
                 {
-                    result += " -> !";
-                }
-                else if (!payload->return_type.proper_type.empty())
-                {
-                    result += " -> " + payload->return_type.proper_type.to_string();
+                    result += " -> " + payload->return_type.to_string();
                 }
                 return result;
             }
@@ -272,7 +268,7 @@ namespace elna::boot
     {
     }
 
-    procedure_type::procedure_type(return_t return_type)
+    procedure_type::procedure_type(type return_type)
         : return_type(std::move(return_type))
     {
     }
@@ -414,14 +410,14 @@ namespace elna::boot
         const type boolean = type(std::make_shared<primitive_type>("Bool", target.bool_properties));
         result->enter("Bool", std::make_shared<type_info>(boolean));
 
-        procedure_type assert_symbol{ procedure_type::return_t() };
+        procedure_type assert_symbol{};
         assert_symbol.parameters.push_back(boolean);
         std::shared_ptr<procedure_info> const assert_info = std::make_shared<procedure_info>(assert_symbol,
             std::vector<std::string>{ "condition" });
         result->enter("assert", assert_info);
 
         const type load_parameter = type(std::make_shared<parameter_type>("T"));
-        procedure_type volatile_load_symbol{ procedure_type::return_t(load_parameter) };
+        procedure_type volatile_load_symbol{ load_parameter };
         volatile_load_symbol.parameters.emplace_back(std::make_shared<pointer_type>(load_parameter));
         std::shared_ptr<procedure_info> const volatile_load_info =
             std::make_shared<procedure_info>(volatile_load_symbol, std::vector<std::string>{ "source" });
@@ -429,7 +425,7 @@ namespace elna::boot
         result->enter("volatile_load", volatile_load_info);
 
         const type store_parameter = type(std::make_shared<parameter_type>("T"));
-        procedure_type volatile_store_symbol{ procedure_type::return_t() };
+        procedure_type volatile_store_symbol{};
         volatile_store_symbol.parameters.emplace_back(std::make_shared<pointer_type>(store_parameter));
         volatile_store_symbol.parameters.push_back(store_parameter);
         std::shared_ptr<procedure_info> const volatile_store_info =
@@ -626,12 +622,11 @@ namespace elna::boot
         }
         else if (const auto procedure = subject.get<procedure_type>())
         {
-            procedure_type::return_t result_return = procedure->return_type;
+            type result_return = procedure->return_type;
 
-            if (!result_return.no_return && !result_return.proper_type.empty())
+            if (!result_return.empty())
             {
-                result_return = procedure_type::return_t(
-                        substitute(result_return.proper_type, parameters, arguments));
+                result_return = substitute(result_return, parameters, arguments);
             }
             const std::shared_ptr<procedure_type> result = std::make_shared<procedure_type>(std::move(result_return));
 
diff --git a/boot/type_check.cc b/boot/type_check.cc
index 15a01dc..ea0bcd5 100644
--- a/boot/type_check.cc
+++ b/boot/type_check.cc
@@ -413,8 +413,8 @@ namespace elna::boot
                     return opaque;
                 }
             }
-            return !procedure->return_type.proper_type.empty()
-                ? find_opaque_type(procedure->return_type.proper_type)
+            return !procedure->return_type.empty()
+                ? find_opaque_type(procedure->return_type)
                 : std::nullopt;
         }
         return std::nullopt;
@@ -723,18 +723,18 @@ namespace elna::boot
             }
             ++parameter_index;
         }
-        if (declaration->heading().return_type.proper_type != nullptr)
+        if (declaration->heading().return_type != nullptr)
         {
-            if (auto opaque = find_opaque_type(this->current_procedure->symbol.return_type.proper_type))
+            if (auto opaque = find_opaque_type(this->current_procedure->symbol.return_type))
             {
                 add_error<type_requirement_error>(
-                        declaration->heading().return_type.proper_type->position(),
+                        declaration->heading().return_type->position(),
                         opaque.value(), type_requirement_error::kind::opaque_return);
             }
-            else if (auto found = find_zero_sized(this->current_procedure->symbol.return_type.proper_type, this->target))
+            else if (auto found = find_zero_sized(this->current_procedure->symbol.return_type, this->target))
             {
                 add_error<type_requirement_error>(
-                        declaration->heading().return_type.proper_type->position(),
+                        declaration->heading().return_type->position(),
                         found.value(), type_requirement_error::kind::zero_sized);
             }
         }
@@ -750,7 +750,7 @@ namespace elna::boot
     void type_analysis_visitor::check_return(const procedure_body& body,
             const source_position position, const std::string& name)
     {
-        const type return_type = this->current_procedure->symbol.return_type.proper_type;
+        const type return_type = this->current_procedure->symbol.return_type;
 
         if (body.return_expression == nullptr)
         {
@@ -990,18 +990,17 @@ namespace elna::boot
                             parameter, type_requirement_error::kind::zero_sized);
                 }
             }
-            if (!procedure->return_type.proper_type.empty())
+            if (!procedure->return_type.empty())
             {
-                if (const auto opaque = find_opaque_type(procedure->return_type.proper_type))
+                if (const auto opaque = find_opaque_type(procedure->return_type))
                 {
                     add_error<type_requirement_error>(declaration->position(),
                             opaque.value(), type_requirement_error::kind::opaque_return);
                 }
-                else if (has_zero_size(procedure->return_type.proper_type, this->target))
+                else if (has_zero_size(procedure->return_type, this->target))
                 {
                     add_error<type_requirement_error>(declaration->position(),
-                            procedure->return_type.proper_type,
-                            type_requirement_error::kind::zero_sized);
+                            procedure->return_type, type_requirement_error::kind::zero_sized);
                 }
             }
         }
@@ -1079,8 +1078,8 @@ namespace elna::boot
                     return true;
                 }
             }
-            return !procedure->return_type.proper_type.empty()
-                && occurs_in(parameter, procedure->return_type.proper_type);
+            return !procedure->return_type.empty()
+                && occurs_in(parameter, procedure->return_type);
         }
         else if (const auto instance = subject.get<instantiated_type>())
         {
@@ -1206,10 +1205,8 @@ namespace elna::boot
                     return false;
                 }
             }
-            return left_procedure->return_type.proper_type.empty()
-                || bind_arguments(parameters, bindings,
-                        left_procedure->return_type.proper_type,
-                        right_procedure->return_type.proper_type);
+            return left_procedure->return_type.empty()
+                || bind_arguments(parameters, bindings, left_procedure->return_type, right_procedure->return_type);
         }
         return true;
     }
@@ -1424,7 +1421,7 @@ namespace elna::boot
                 // just bound.
                 if (const auto substituted = callable_type.get<procedure_type>())
                 {
-                    call->type_decoration = substituted->return_type.proper_type;
+                    call->type_decoration = substituted->return_type;
                 }
             }
         }