Type check the return statement

boot/ast.cc

@@ -33,14 +33,6 @@ namespace elna::boot
         return this->source_position;
     }
 
-    statement::statement()
-    {
-    }
-
-    statement::~statement()
-    {
-    }
-
     assign_statement *statement::is_assign()
     {
         return nullptr;
@@ -71,14 +63,6 @@ namespace elna::boot
         return nullptr;
     }
 
-    expression::expression()
-    {
-    }
-
-    expression::~expression()
-    {
-    }
-
     cast_expression *expression::is_cast()
     {
         return nullptr;
@@ -114,39 +98,6 @@ namespace elna::boot
         return nullptr;
     }
 
-    void expression::accept(parser_visitor *visitor)
-    {
-        if (cast_expression *node = is_cast())
-        {
-            return node->accept(visitor);
-        }
-        else if (traits_expression *node = is_traits())
-        {
-            return node->accept(visitor);
-        }
-        else if (binary_expression *node = is_binary())
-        {
-            return node->accept(visitor);
-        }
-        else if (unary_expression *node = is_unary())
-        {
-            return node->accept(visitor);
-        }
-        else if (designator_expression *node = is_designator())
-        {
-            return node->accept(visitor);
-        }
-        else if (procedure_call *node = is_call_expression())
-        {
-            return node->accept(visitor);
-        }
-        else if (literal_expression *node = is_literal())
-        {
-            return node->accept(visitor);
-        }
-        __builtin_unreachable();
-    }
-
     type_expression::type_expression(const struct position position)
         : node(position)
     {
@@ -182,35 +133,6 @@ namespace elna::boot
         return nullptr;
     }
 
-    void type_expression::accept(parser_visitor *visitor)
-    {
-        if (std::shared_ptr<primitive_type_expression> node = is_primitive())
-        {
-            return node->accept(visitor);
-        }
-        else if (std::shared_ptr<array_type_expression> node = is_array())
-        {
-            return node->accept(visitor);
-        }
-        else if (std::shared_ptr<pointer_type_expression> node = is_pointer())
-        {
-            return node->accept(visitor);
-        }
-        else if (std::shared_ptr<record_type_expression> node = is_record())
-        {
-            return node->accept(visitor);
-        }
-        else if (std::shared_ptr<union_type_expression> node = is_union())
-        {
-            return node->accept(visitor);
-        }
-        else if (std::shared_ptr<procedure_type_expression> node = is_procedure())
-        {
-            return node->accept(visitor);
-        }
-        __builtin_unreachable();
-    }
-
     primitive_type_expression::primitive_type_expression(const struct position position, const std::string& name)
         : type_expression(position), name(name)
     {
@@ -301,8 +223,8 @@ namespace elna::boot
     }
 
     variable_declaration::variable_declaration(const struct position position, const std::string& identifier,
-            std::shared_ptr<type_expression> type, const bool exported)
-        : definition(position, identifier, exported), m_type(type)
+            std::shared_ptr<type_expression> variable_type, const bool exported)
+        : definition(position, identifier, exported), m_variable_type(variable_type)
     {
     }
 
@@ -313,7 +235,7 @@ namespace elna::boot
 
     type_expression& variable_declaration::variable_type()
     {
-        return *m_type;
+        return *m_variable_type;
     }
 
     definition::definition(const struct position position, const std::string& identifier, const bool exported)
@@ -462,47 +384,16 @@ namespace elna::boot
         return this;
     }
 
-    void literal_expression::accept(parser_visitor *visitor)
-    {
-        if (literal<std::int32_t> *node = is_int())
-        {
-            return node->accept(visitor);
-        }
-        else if (literal<std::uint32_t> *node = is_word())
-        {
-            return node->accept(visitor);
-        }
-        else if (literal<double> *node = is_float())
-        {
-            return node->accept(visitor);
-        }
-        else if (literal<bool> *node = is_bool())
-        {
-            return node->accept(visitor);
-        }
-        else if (literal<unsigned char> *node = is_char())
-        {
-            return node->accept(visitor);
-        }
-        else if (literal<std::nullptr_t> *node = is_nil())
-        {
-            return node->accept(visitor);
-        }
-        else if (literal<std::string> *node = is_string())
-        {
-            return node->accept(visitor);
-        }
-        else
-        {
-            __builtin_unreachable();
-        }
-    }
-
     defer_statement::defer_statement(const struct position position)
         : node(position)
     {
     }
 
+    void defer_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
     defer_statement *defer_statement::is_defer()
     {
         return this;
@@ -529,11 +420,37 @@ namespace elna::boot
         return this;
     }
 
+    void designator_expression::accept(parser_visitor *visitor)
+    {
+        if (variable_expression *node = is_variable())
+        {
+            return visitor->visit(node);
+        }
+        else if (array_access_expression *node = is_array_access())
+        {
+            return visitor->visit(node);
+        }
+        else if (field_access_expression *node = is_field_access())
+        {
+            return visitor->visit(node);
+        }
+        else if (dereference_expression *node = is_dereference())
+        {
+            return visitor->visit(node);
+        }
+        __builtin_unreachable();
+    }
+
     variable_expression::variable_expression(const struct position position, const std::string& name)
         : node(position), name(name)
     {
     }
 
+    void variable_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
     variable_expression *variable_expression::is_variable()
     {
         return this;
@@ -545,6 +462,11 @@ namespace elna::boot
     {
     }
 
+    void array_access_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
     expression& array_access_expression::index()
     {
         return *m_index;
@@ -572,6 +494,11 @@ namespace elna::boot
     {
     }
 
+    void field_access_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
     expression& field_access_expression::base()
     {
         return *m_base;
@@ -598,6 +525,11 @@ namespace elna::boot
     {
     }
 
+    void dereference_expression::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
     expression& dereference_expression::base()
     {
         return *m_base;
@@ -686,6 +618,11 @@ namespace elna::boot
     {
     }
 
+    void procedure_call::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
     procedure_call *procedure_call::is_call_statement()
     {
         return this;
@@ -780,6 +717,11 @@ namespace elna::boot
     {
     }
 
+    void return_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
     return_statement *return_statement::is_return()
     {
         return this;
@@ -801,6 +743,11 @@ namespace elna::boot
     {
     }
 
+    void assign_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
     assign_statement *assign_statement::is_assign()
     {
         return this;
@@ -847,6 +794,11 @@ namespace elna::boot
     {
     }
 
+    void if_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
     if_statement *if_statement::is_if()
     {
         return this;
@@ -877,6 +829,11 @@ namespace elna::boot
     {
     }
 
+    void while_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
     while_statement *while_statement::is_while()
     {
         return this;