Replace noreturn type with an attribute

1 files changed, 9 insertions, 14 deletions

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));