Rename AST types to type expressions

This reverts commit 18602d00a118e69d4ccc45287e89a16b86c1d92e.

boot/ast.cc

@@ -23,197 +23,167 @@ namespace boot
 {
     void empty_visitor::visit(variable_declaration *)
     {
+        __builtin_unreachable();
     }
 
-    void empty_visitor::visit(constant_definition *definition)
+    void empty_visitor::visit(constant_definition *)
     {
-        definition->body().accept(this);
+        __builtin_unreachable();
     }
 
-    void empty_visitor::visit(procedure_definition *definition)
+    void empty_visitor::visit(procedure_definition *)
     {
-        definition->heading().accept(this);
+        __builtin_unreachable();
-        if (definition->body != nullptr)
-        {
-            definition->body->accept(this);
-        }
     }
 
-    void empty_visitor::visit(type_definition *definition)
+    void empty_visitor::visit(type_definition *)
     {
-        definition->body().accept(this);
+        __builtin_unreachable();
     }
 
-    void empty_visitor::visit(procedure_call *call)
+    void empty_visitor::visit(procedure_call *)
     {
-        for (expression *const argument : call->arguments)
+        __builtin_unreachable();
-        {
-            argument->accept(this);
-        }
     }
 
-    void empty_visitor::visit(traits_expression *trait)
+    void empty_visitor::visit(traits_expression *)
     {
-        trait->type().accept(this);
+        __builtin_unreachable();
     }
 
-    void empty_visitor::visit(cast_expression *expression)
+    void empty_visitor::visit(cast_expression *)
     {
-        expression->target().accept(this);
+        __builtin_unreachable();
-        expression->value().accept(this);
     }
 
-    void empty_visitor::visit(assign_statement *statement)
+    void empty_visitor::visit(assign_statement *)
     {
-        statement->rvalue().accept(this);
+        __builtin_unreachable();
     }
 
-    void empty_visitor::visit(if_statement *statement)
+    void empty_visitor::visit(if_statement *)
     {
-        statement->body().prerequisite().accept(this);
+        __builtin_unreachable();
-        for (const auto body_statement : statement->body().statements)
-        {
-            body_statement->accept(this);
-        }
     }
 
-    void empty_visitor::visit(while_statement *statement)
+    void empty_visitor::visit(while_statement *)
     {
-        statement->body().prerequisite().accept(this);
+        __builtin_unreachable();
-        for (const auto body_statement : statement->body().statements)
-        {
-            body_statement->accept(this);
-        }
     }
 
-    void empty_visitor::visit(block *block)
+    void empty_visitor::visit(return_statement *)
     {
-        for (constant_definition *const constant : block->constants)
+        __builtin_unreachable();
-        {
-            constant->accept(this);
-        }
-        for (variable_declaration *const variable : block->variables)
-        {
-            variable->accept(this);
-        }
-        for (statement *const body_statement : block->body)
-        {
-            body_statement->accept(this);
-        }
     }
 
-    void empty_visitor::visit(program *program)
+    void empty_visitor::visit(defer_statement *)
     {
-        visit(reinterpret_cast<block *>(program));
+        __builtin_unreachable();
-        for (type_definition *const type : program->types)
-        {
-            type->accept(this);
-        }
-        for (procedure_definition *const procedure : program->procedures)
-        {
-            procedure->accept(this);
-        }
     }
 
-    void empty_visitor::visit(binary_expression *expression)
+    void empty_visitor::visit(block *)
     {
-        expression->lhs().accept(this);
+        __builtin_unreachable();
-        expression->rhs().accept(this);
     }
 
-    void empty_visitor::visit(unary_expression *expression)
+    void empty_visitor::visit(program *)
     {
-        expression->operand().accept(this);
+        __builtin_unreachable();
     }
 
-    void empty_visitor::visit(basic_type *)
+    void empty_visitor::visit(binary_expression *)
     {
+        __builtin_unreachable();
     }
 
-    void empty_visitor::visit(array_type *expression)
+    void empty_visitor::visit(unary_expression *)
     {
-        expression->base().accept(this);
+        __builtin_unreachable();
     }
 
-    void empty_visitor::visit(pointer_type *expression)
+    void empty_visitor::visit(primitive_type_expression *)
     {
-        expression->base().accept(this);
+        __builtin_unreachable();
     }
 
-    void empty_visitor::visit(record_type *expression)
+    void empty_visitor::visit(array_type_expression *)
     {
-        for (auto& field : expression->fields)
+        __builtin_unreachable();
-        {
-            field.second->accept(this);
-        }
     }
 
-    void empty_visitor::visit(union_type *expression)
+    void empty_visitor::visit(pointer_type_expression *)
     {
-        for (auto& field : expression->fields)
+        __builtin_unreachable();
-        {
-            field.second->accept(this);
-        }
     }
 
-    void empty_visitor::visit(procedure_type *expression)
+    void empty_visitor::visit(record_type_expression *)
     {
-        for (auto parameter : expression->parameters)
+        __builtin_unreachable();
-        {
+    }
-            parameter->accept(this);
+
-        }
+    void empty_visitor::visit(union_type_expression *)
-        if (expression->return_type != nullptr)
+    {
-        {
+        __builtin_unreachable();
-            expression->return_type->accept(this);
+    }
-        }
+
+    void empty_visitor::visit(procedure_type_expression *)
+    {
+        __builtin_unreachable();
     }
 
     void empty_visitor::visit(variable_expression *)
     {
+        __builtin_unreachable();
     }
 
-    void empty_visitor::visit(array_access_expression *expression)
+    void empty_visitor::visit(array_access_expression *)
     {
-        expression->base().accept(this);
+        __builtin_unreachable();
-        expression->index().accept(this);
     }
 
-    void empty_visitor::visit(field_access_expression *expression)
+    void empty_visitor::visit(field_access_expression *)
     {
-        expression->base().accept(this);
+        __builtin_unreachable();
     }
 
-    void empty_visitor::visit(dereference_expression *expression)
+    void empty_visitor::visit(dereference_expression *)
     {
-        expression->base().accept(this);
+        __builtin_unreachable();
     }
 
     void empty_visitor::visit(number_literal<std::int32_t> *)
     {
+        __builtin_unreachable();
     }
 
     void empty_visitor::visit(number_literal<std::uint32_t> *)
     {
+        __builtin_unreachable();
     }
 
     void empty_visitor::visit(number_literal<double> *)
     {
+        __builtin_unreachable();
     }
 
     void empty_visitor::visit(number_literal<bool> *)
     {
+        __builtin_unreachable();
     }
 
     void empty_visitor::visit(number_literal<unsigned char> *)
     {
+        __builtin_unreachable();
     }
 
     void empty_visitor::visit(number_literal<std::nullptr_t> *)
     {
+        __builtin_unreachable();
     }
 
     void empty_visitor::visit(number_literal<std::string> *)
     {
+        __builtin_unreachable();
     }
 
     node::node(const struct position position)
@@ -234,133 +204,80 @@ namespace boot
     {
     }
 
-    top_type::top_type(const struct position position)
+    type_expression::type_expression(const struct position position)
         : node(position)
     {
     }
 
-    std::shared_ptr<basic_type> top_type::is_basic()
+    primitive_type_expression::primitive_type_expression(const struct position position, const std::string& name)
-    {
+        : type_expression(position), m_name(name)
-        return nullptr;
-    }
-
-    std::shared_ptr<array_type> top_type::is_array()
-    {
-        return nullptr;
-    }
-
-    std::shared_ptr<record_type> top_type::is_record()
-    {
-        return nullptr;
-    }
-
-    std::shared_ptr<union_type> top_type::is_union()
-    {
-        return nullptr;
-    }
-
-    std::shared_ptr<pointer_type> top_type::is_pointer()
-    {
-        return nullptr;
-    }
-
-    std::shared_ptr<procedure_type> top_type::is_procedure()
-    {
-        return nullptr;
-    }
-
-    basic_type::basic_type(const struct position position, const std::string& name)
-        : top_type(position), m_name(name)
     {
     }
 
-    void basic_type::accept(parser_visitor *visitor)
+    void primitive_type_expression::accept(parser_visitor *visitor)
     {
         visitor->visit(this);
     }
 
-    const std::string& basic_type::base_name()
+    const std::string& primitive_type_expression::base_name()
     {
         return m_name;
     }
 
-    std::shared_ptr<basic_type> basic_type::is_basic()
+    array_type_expression::array_type_expression(const struct position position,
-    {
+            std::shared_ptr<type_expression> base, const std::uint32_t size)
-        return std::static_pointer_cast<basic_type>(shared_from_this());
+        : type_expression(position), m_base(base), size(size)
-    }
-
-    array_type::array_type(const struct position position, std::shared_ptr<top_type> base, const std::uint32_t size)
-        : top_type(position), m_base(base), size(size)
     {
     }
 
-    void array_type::accept(parser_visitor *visitor)
+    void array_type_expression::accept(parser_visitor *visitor)
     {
         visitor->visit(this);
     }
 
-    top_type& array_type::base()
+    type_expression& array_type_expression::base()
     {
         return *m_base;
     }
 
-    std::shared_ptr<array_type> array_type::is_array()
+    pointer_type_expression::pointer_type_expression(const struct position position,
-    {
+            std::shared_ptr<type_expression> base)
-        return std::static_pointer_cast<array_type>(shared_from_this());
+        : type_expression(position), m_base(base)
-    }
-
-    pointer_type::pointer_type(const struct position position, std::shared_ptr<top_type> base)
-        : top_type(position), m_base(base)
     {
     }
 
-    void pointer_type::accept(parser_visitor *visitor)
+    void pointer_type_expression::accept(parser_visitor *visitor)
     {
         visitor->visit(this);
     }
 
-    top_type& pointer_type::base()
+    type_expression& pointer_type_expression::base()
     {
         return *m_base;
     }
 
-    std::shared_ptr<pointer_type> pointer_type::is_pointer()
+    record_type_expression::record_type_expression(const struct position position, fields_t&& fields)
-    {
+        : type_expression(position), fields(std::move(fields))
-        return std::static_pointer_cast<pointer_type>(shared_from_this());
-    }
-
-    record_type::record_type(const struct position position, fields_t&& fields)
-        : top_type(position), fields(std::move(fields))
     {
     }
 
-    void record_type::accept(parser_visitor *visitor)
+    void record_type_expression::accept(parser_visitor *visitor)
     {
         visitor->visit(this);
     }
 
-    std::shared_ptr<record_type> record_type::is_record()
+    union_type_expression::union_type_expression(const struct position position, fields_t&& fields)
-    {
+        : type_expression(position), fields(std::move(fields))
-        return std::static_pointer_cast<record_type>(shared_from_this());
-    }
-
-    union_type::union_type(const struct position position, fields_t&& fields)
-        : top_type(position), fields(std::move(fields))
     {
     }
 
-    std::shared_ptr<union_type> union_type::is_union()
+    void union_type_expression::accept(parser_visitor *visitor)
-    {
-        return std::static_pointer_cast<union_type>(shared_from_this());
-    }
-
-    void union_type::accept(parser_visitor *visitor)
     {
         visitor->visit(this);
     }
 
     variable_declaration::variable_declaration(const struct position position, const std::string& identifier,
-            std::shared_ptr<top_type> type, const bool exported)
+            std::shared_ptr<type_expression> type, const bool exported)
         : definition(position, identifier, exported), m_type(type)
     {
     }
@@ -370,7 +287,7 @@ namespace boot
         visitor->visit(this);
     }
 
-    top_type& variable_declaration::variable_type()
+    type_expression& variable_declaration::variable_type()
     {
         return *m_type;
     }
@@ -401,27 +318,23 @@ namespace boot
         delete m_body;
     }
 
-    procedure_type::procedure_type(const struct position position, std::shared_ptr<top_type> return_type)
+    procedure_type_expression::procedure_type_expression(const struct position position,
-        : top_type(position), return_type(return_type), no_return(false)
+            std::shared_ptr<type_expression> return_type)
+        : type_expression(position), return_type(return_type), no_return(false)
     {
     }
 
-    procedure_type::procedure_type(const struct position position, no_return_t)
+    procedure_type_expression::procedure_type_expression(const struct position position, no_return_t)
-        : top_type(position), return_type(nullptr), no_return(true)
+        : type_expression(position), return_type(nullptr), no_return(true)
     {
     }
 
-    void procedure_type::accept(parser_visitor *visitor)
+    void procedure_type_expression::accept(parser_visitor *visitor)
     {
         visitor->visit(this);
     }
 
-    std::shared_ptr<procedure_type> procedure_type::is_procedure()
+    procedure_type_expression::~procedure_type_expression()
-    {
-        return std::static_pointer_cast<procedure_type>(shared_from_this());
-    }
-
-    procedure_type::~procedure_type()
     {
         for (auto parameter : this->parameters)
         {
@@ -430,9 +343,8 @@ namespace boot
     }
 
     procedure_definition::procedure_definition(const struct position position, const std::string& identifier,
-            const bool exported, std::shared_ptr<procedure_type> heading,
+            const bool exported, std::shared_ptr<procedure_type_expression> heading, block *body)
-            block *const body, expression *const returning)
+        : definition(position, identifier, exported), m_heading(heading), body(body)
-        : definition(position, identifier, exported), m_heading(heading), body(body), returning(returning)
     {
     }
 
@@ -441,7 +353,7 @@ namespace boot
         visitor->visit(this);
     }
 
-    procedure_type& procedure_definition::heading()
+    procedure_type_expression& procedure_definition::heading()
     {
         return *m_heading;
     }
@@ -449,11 +361,10 @@ namespace boot
     procedure_definition::~procedure_definition()
     {
         delete body;
-        delete returning;
     }
 
     type_definition::type_definition(const struct position position, const std::string& identifier,
-            const bool exported, std::shared_ptr<top_type> body)
+            const bool exported, std::shared_ptr<type_expression> body)
         : definition(position, identifier, exported), m_body(body)
     {
     }
@@ -463,7 +374,7 @@ namespace boot
         visitor->visit(this);
     }
 
-    top_type& type_definition::body()
+    type_expression& type_definition::body()
     {
         return *m_body;
     }
@@ -520,6 +431,24 @@ namespace boot
     {
     }
 
+    defer_statement::defer_statement(const struct position position)
+        : node(position)
+    {
+    }
+
+    void defer_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    defer_statement::~defer_statement()
+    {
+        for (statement *body_statement : statements)
+        {
+            delete body_statement;
+        }
+    }
+
     designator_expression::designator_expression()
     {
     }
@@ -711,7 +640,7 @@ namespace boot
     }
 
     cast_expression::cast_expression(const struct position position,
-            std::shared_ptr<top_type> target, expression *value)
+            std::shared_ptr<type_expression> target, expression *value)
         : node(position), m_target(target), m_value(value)
     {
     }
@@ -721,7 +650,7 @@ namespace boot
         visitor->visit(this);
     }
 
-    top_type& cast_expression::target()
+    type_expression& cast_expression::target()
     {
         return *m_target;
     }
@@ -737,7 +666,7 @@ namespace boot
     }
 
     traits_expression::traits_expression(const struct position position,
-            const std::string& name, std::shared_ptr<top_type> type)
+            const std::string& name, std::shared_ptr<type_expression> type)
         : node(position), m_type(type), name(name)
     {
     }
@@ -747,7 +676,7 @@ namespace boot
         visitor->visit(this);
     }
 
-    top_type& traits_expression::type()
+    type_expression& traits_expression::type()
     {
         return *m_type;
     }
@@ -771,6 +700,26 @@ namespace boot
         }
     }
 
+    return_statement::return_statement(const struct position position, expression *return_expression)
+        : node(position), m_return_expression(return_expression)
+    {
+    }
+
+    void return_statement::accept(parser_visitor *visitor)
+    {
+        visitor->visit(this);
+    }
+
+    expression *return_statement::return_expression()
+    {
+        return m_return_expression;
+    }
+
+    return_statement::~return_statement()
+    {
+        delete m_return_expression;
+    }
+
     void assign_statement::accept(parser_visitor *visitor)
     {
         visitor->visit(this);

boot/lexer.ll

@@ -125,6 +125,9 @@ return                  {
 cast                    {
                             return yy::parser::make_CAST(this->location);
                         }
+defer                   {
+                            return yy::parser::make_DEFER(this->location);
+                        }
 [A-Za-z_][A-Za-z0-9_]*  {
                             return yy::parser::make_IDENTIFIER(yytext, this->location);
                         }

boot/parser.yy

@@ -106,6 +106,7 @@ along with GCC; see the file COPYING3.  If not see
     RETURN "return"
     BEGIN_BLOCK "begin"
     END_BLOCK "end"
+    DEFER "defer"
 %token OR "or" AND "and" XOR "xor"
     EQUALS "=" NOT_EQUAL "<>" LESS_THAN "<" GREATER_THAN ">" LESS_EQUAL "<=" GREATER_EQUAL ">="
     SHIFT_LEFT "<<" SHIFT_RIGHT ">>"
@@ -124,7 +125,7 @@ along with GCC; see the file COPYING3.  If not see
 %type <std::vector<elna::boot::variable_declaration *>> variable_declarations variable_part variable_declaration
     formal_parameters formal_parameter_list;
 %type <elna::boot::variable_declaration *> formal_parameter
-%type <std::shared_ptr<elna::boot::top_type>> type_expression;
+%type <std::shared_ptr<elna::boot::type_expression>> type_expression;
 %type <elna::boot::traits_expression *> traits_expression;
 %type <elna::boot::expression *> expression operand;
 %type <elna::boot::unary_expression *> unary_expression;
@@ -135,24 +136,26 @@ along with GCC; see the file COPYING3.  If not see
 %type <elna::boot::procedure_call*> call_expression;
 %type <elna::boot::while_statement *> while_statement;
 %type <elna::boot::if_statement *> if_statement;
-%type <elna::boot::expression *> return_statement;
+%type <elna::boot::return_statement *> return_statement;
 %type <elna::boot::statement *> statement;
-%type <std::vector<elna::boot::statement *>> statements statement_part;
+%type <std::vector<elna::boot::statement *>> statements;
 %type <elna::boot::procedure_definition *> procedure_definition;
-%type <std::shared_ptr<elna::boot::procedure_type>> procedure_heading;
+%type <std::shared_ptr<elna::boot::procedure_type_expression>> procedure_heading;
-%type <std::vector<elna::boot::procedure_definition *>> procedure_definitions;
+%type <std::vector<elna::boot::procedure_definition *>> procedure_definitions procedure_part;
 %type <elna::boot::type_definition *> type_definition;
 %type <std::vector<elna::boot::type_definition *>> type_definitions type_part;
 %type <elna::boot::block *> block;
 %type <elna::boot::field_t> field_declaration;
-%type <std::vector<std::pair<std::string, std::shared_ptr<elna::boot::top_type>>>> optional_fields required_fields;
+%type <std::vector<std::pair<std::string, std::shared_ptr<elna::boot::type_expression>>>>
+    optional_fields required_fields;
 %type <std::vector<elna::boot::conditional_statements *>> elsif_then_statements elsif_do_statements;
 %type <elna::boot::cast_expression *> cast_expression;
+%type <elna::boot::defer_statement *> defer_statement;
 %type <std::pair<std::string, bool>> identifier_definition;
 %type <std::vector<std::pair<std::string, bool>>> identifier_definitions;
 %%
 program:
-    constant_part type_part variable_part procedure_definitions "begin" statements "end" "."
+    constant_part type_part variable_part procedure_part "begin" statements "end" "."
         {
             auto tree = new elna::boot::program(elna::boot::make_position(@5));
 
@@ -164,13 +167,13 @@ program:
 
             driver.tree.reset(tree);
         }
-block: constant_part variable_part statement_part
+block: constant_part variable_part "begin" statements "end"
         {
-            $$ = new elna::boot::block(elna::boot::make_position(@1));
+            $$ = new elna::boot::block(elna::boot::make_position(@3));
 
             std::swap($$->constants, $1);
             std::swap($$->variables, $2);
-            std::swap($$->body, $3);
+            std::swap($$->body, $4);
         }
 identifier_definition:
     IDENTIFIER "*"
@@ -191,24 +194,24 @@ identifier_definitions:
 procedure_heading:
     formal_parameter_list
         {
-            $$ = std::make_shared<elna::boot::procedure_type>(elna::boot::make_position(@1));
+            $$ = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1));
             std::swap($1, $$->parameters);
         }
     | formal_parameter_list "->" "!"
         {
-            $$ = std::make_shared<elna::boot::procedure_type>(elna::boot::make_position(@1), elna::boot::no_return);
+            $$ = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1),
+                elna::boot::no_return);
             std::swap($1, $$->parameters);
         }
     | formal_parameter_list "->" type_expression
         {
-            $$ = std::make_shared<elna::boot::procedure_type>(elna::boot::make_position(@1), $3);
+            $$ = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1), $3);
             std::swap($1, $$->parameters);
         }
 procedure_definition:
-    "proc" identifier_definition procedure_heading ";" block return_statement "end"
+    "proc" identifier_definition procedure_heading ";" block
         {
-            $$ = new elna::boot::procedure_definition(elna::boot::make_position(@1), $2.first, $2.second,
+            $$ = new elna::boot::procedure_definition(elna::boot::make_position(@1), $2.first, $2.second, $3, $5);
-                $3, $5, $6);
         }
     | "proc" identifier_definition procedure_heading ";" "extern"
         {
@@ -220,7 +223,10 @@ procedure_definitions:
             std::swap($$, $2);
             $$.emplace($$.cbegin(), std::move($1));
         }
-    | /* no procedure definitions */ {}
+    | procedure_definition { $$.emplace_back(std::move($1)); }
+procedure_part:
+    /* no procedure definitions */ {}
+    | procedure_definitions { std::swap($$, $1); }
 assign_statement: designator_expression ":=" expression
         {
             $$ = new elna::boot::assign_statement(elna::boot::make_position(@1), $1, $3);
@@ -275,12 +281,15 @@ if_statement:
             $$ = new elna::boot::if_statement(elna::boot::make_position(@1), then, _else);
             std::swap($5, $$->branches);
         }
-return_statement:
+return_statement: "return" expression
-    "return" expression
         {
-            $$ = $2;
+            $$ = new elna::boot::return_statement(elna::boot::make_position(@1), $2);
+        }
+defer_statement: DEFER statements "end"
+        {
+            $$ = new elna::boot::defer_statement(elna::boot::make_position(@1));
+            std::swap($2, $$->statements);
         }
-    | /* no return statement */ { $$ = nullptr; }
 literal:
     INTEGER
         {
@@ -451,21 +460,17 @@ statement:
     assign_statement { $$ = $1; }
     | while_statement { $$ = $1; }
     | if_statement { $$ = $1; }
+    | return_statement { $$ = $1; }
     | call_expression { $$ = $1; }
+    | defer_statement { $$ = $1; }
 statements:
     statement ";" statements
         {
             std::swap($$, $3);
-            $$.emplace($$.cbegin(), $1);
+            $$.insert($$.cbegin(), $1);
-        }
-    | statement
-        {
-            $$.push_back($1);
         }
+    | statement { $$.push_back($1); }
     | /* no statements */ {}
-statement_part:
-    "begin" statements { std::swap($$, $2); }
-    | {}
 field_declaration:
     IDENTIFIER ":" type_expression { $$ = std::make_pair($1, $3); }
 required_fields:
@@ -481,19 +486,19 @@ optional_fields:
 type_expression:
     "[" INTEGER "]" type_expression
         {
-            $$ = std::make_shared<elna::boot::array_type>(elna::boot::make_position(@1), $4, $2);
+            $$ = std::make_shared<elna::boot::array_type_expression>(elna::boot::make_position(@1), $4, $2);
         }
     | "^" type_expression
         {
-            $$ = std::make_shared<elna::boot::pointer_type>(elna::boot::make_position(@1), $2);
+            $$ = std::make_shared<elna::boot::pointer_type_expression>(elna::boot::make_position(@1), $2);
         }
     | "record" optional_fields "end"
         {
-            $$ = std::make_shared<elna::boot::record_type>(elna::boot::make_position(@1), std::move($2));
+            $$ = std::make_shared<elna::boot::record_type_expression>(elna::boot::make_position(@1), std::move($2));
         }
     | "union" required_fields "end"
         {
-            $$ = std::make_shared<elna::boot::union_type>(elna::boot::make_position(@1), std::move($2));
+            $$ = std::make_shared<elna::boot::union_type_expression>(elna::boot::make_position(@1), std::move($2));
         }
     | "proc" procedure_heading
         {
@@ -501,7 +506,7 @@ type_expression:
         }
     | IDENTIFIER
         {
-            $$ = std::make_shared<elna::boot::basic_type>(elna::boot::make_position(@1), $1);
+            $$ = std::make_shared<elna::boot::primitive_type_expression>(elna::boot::make_position(@1), $1);
         }
 variable_declaration: identifier_definitions ":" type_expression
         {

boot/semantic.cc

@@ -0,0 +1,33 @@
+/* Semantic analysis visitors.
+   Copyright (C) 2025 Free Software Foundation, Inc.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#include "elna/boot/semantic.h"
+
+namespace elna
+{
+namespace boot
+{
+    name_analysis_visitor::name_analysis_visitor(std::shared_ptr<symbol_table<>> table)
+        : table(table)
+    {
+    }
+
+    void name_analysis_visitor::visit(program *program)
+    {
+    }
+}
+}

boot/symbol.cc

@@ -0,0 +1,32 @@
+/* Symbol definitions.
+   Copyright (C) 2025 Free Software Foundation, Inc.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#include "elna/boot/symbol.h"
+
+namespace elna
+{
+namespace boot
+{
+    type::~type()
+    {
+    }
+
+    info::~info()
+    {
+    }
+}
+}

gcc/Make-lang.in

@@ -46,6 +46,8 @@ elna_OBJS = \
 	elna/driver.o \
 	elna/lexer.o \
 	elna/parser.o \
+	elna/semantic.o \
+	elna/symbol.o \
 	elna/result.o \
 	$(END)
 
@@ -134,7 +136,7 @@ elna.stagefeedback: stagefeedback-start
 	-mv elna/*$(objext) stagefeedback/elna
 
 ELNA_INCLUDES = -I $(srcdir)/elna/include -I elna/generated
-ELNA_CXXFLAGS = -std=c++11
+ELNA_CXXFLAGS = -std=c++14
 
 elna/%.o: elna/boot/%.cc elna/generated/parser.hh elna/generated/location.hh
 	$(COMPILE) $(ELNA_CXXFLAGS) $(ELNA_INCLUDES) $<

gcc/elna-generic.cc

@@ -164,8 +164,8 @@ namespace gcc
 
     void generic_visitor::visit(boot::cast_expression *expression)
     {
-        tree cast_target = build_type(expression->target());
+        expression->target().accept(this);
-        gcc_assert(cast_target != NULL_TREE);
+        tree cast_target = this->current_expression;
 
         expression->value().accept(this);
 
@@ -294,7 +294,6 @@ namespace gcc
         if (definition->body != nullptr)
         {
             definition->body->accept(this);
-            visit_return(definition->returning);
             tree mapping = leave_scope();
 
             BLOCK_SUPERCONTEXT(BIND_EXPR_BLOCK(mapping)) = fndecl;
@@ -335,7 +334,7 @@ namespace gcc
         {
             BLOCK_SUPERCONTEXT(it) = new_block;
         }
-        tree bind_expr = build3(BIND_EXPR, void_type_node, variables, f_binding_level->statement_list, new_block);
+        tree bind_expr = build3(BIND_EXPR, void_type_node, variables, chain_defer(), new_block);
         this->symbol_map = this->symbol_map->scope();
 
         f_binding_level = f_binding_level->level_chain;
@@ -732,15 +731,16 @@ namespace gcc
     void generic_visitor::visit(boot::type_definition *definition)
     {
         location_t definition_location = get_location(&definition->position());
-        tree tree_type = build_type(definition->body());
+        definition->body().accept(this);
+
         tree definition_tree = build_decl(definition_location, TYPE_DECL,
-                get_identifier(definition->identifier.c_str()), tree_type);
+                get_identifier(definition->identifier.c_str()), this->current_expression);
-        auto result = this->symbol_map->enter(definition->identifier, tree_type);
+        auto result = this->symbol_map->enter(definition->identifier, this->current_expression);
 
         if (result)
         {
             TREE_PUBLIC(definition_tree) = definition->exported;
-            TYPE_NAME(tree_type) = get_identifier(definition->identifier.c_str());
+            TYPE_NAME(this->current_expression) = get_identifier(definition->identifier.c_str());
         }
         else
         {
@@ -748,138 +748,45 @@ namespace gcc
                     "type '%s' already declared in this scope",
                     definition->identifier.c_str());
         }
+        this->current_expression = NULL_TREE;
     }
 
-    tree generic_visitor::build_procedure_type(boot::procedure_type& type)
+    tree generic_visitor::build_procedure_type(boot::procedure_type_expression& type)
     {
         std::vector<tree> parameter_types(type.parameters.size());
 
         for (std::size_t i = 0; i < type.parameters.size(); ++i)
         {
-            parameter_types[i] = build_type(type.parameters.at(i)->variable_type());
+            boot::type_expression& parameter_type = type.parameters.at(i)->variable_type();
+            parameter_type.accept(this);
+            parameter_types[i] = this->current_expression;
         }
-        tree return_type = type.return_type == nullptr
+        tree return_type = void_type_node;
-            ? void_type_node
+
-            : build_type(*type.return_type);
+        if (type.return_type != nullptr)
+        {
+            type.return_type->accept(this);
+            return_type = this->current_expression;
+        }
+        this->current_expression = NULL_TREE;
 
         return build_function_type_array(return_type, type.parameters.size(), parameter_types.data());
     }
 
-    tree generic_visitor::build_type(boot::top_type& type)
-    {
-        if (std::shared_ptr<boot::basic_type> basic_type = type.is_basic())
-        {
-            tree symbol = this->lookup(basic_type->base_name());
-
-            if (symbol != NULL_TREE && TYPE_P(symbol))
-            {
-                return symbol;
-            }
-            error_at(get_location(&basic_type->position()),
-                    "type '%s' not declared", basic_type->base_name().c_str());
-
-            return error_mark_node;
-        }
-        else if (std::shared_ptr<boot::array_type> array_type = type.is_array())
-        {
-            tree lower_bound = build_int_cst_type(integer_type_node, 0);
-            tree upper_bound = build_int_cst_type(integer_type_node, array_type->size);
-            tree base_type = build_type(array_type->base());
-
-            if (base_type == NULL_TREE || base_type == error_mark_node)
-            {
-                return base_type;
-            }
-            tree range_type = build_range_type(integer_type_node, lower_bound, upper_bound);
-
-            return build_array_type(base_type, range_type);
-        }
-        else if (std::shared_ptr<boot::pointer_type> pointer_type = type.is_pointer())
-        {
-            tree base_type = build_type(pointer_type->base());
-
-            if (base_type == NULL_TREE || base_type == error_mark_node)
-            {
-                return base_type;
-            }
-            return build_pointer_type_for_mode(base_type, VOIDmode, true);
-        }
-        else if (std::shared_ptr<boot::record_type> record_type = type.is_record())
-        {
-            std::set<std::string> field_names;
-            tree record_type_node = make_node(RECORD_TYPE);
-
-            for (auto& field : record_type->fields)
-            {
-                if (field_names.find(field.first) != field_names.cend())
-                {
-                    error_at(get_location(&field.second->position()), "repeated field name");
-                    return error_mark_node;
-                }
-                field_names.insert(field.first);
-
-                tree field_type = build_type(*field.second);
-                if (field_type == NULL_TREE || field_type == error_mark_node)
-                {
-                    return field_type;
-                }
-                tree field_declaration = build_field(get_location(&field.second->position()),
-                        record_type_node, field.first, field_type);
-                TYPE_FIELDS(record_type_node) = chainon(TYPE_FIELDS(record_type_node), field_declaration);
-            }
-            layout_type(record_type_node);
-
-            return record_type_node;
-        }
-        else if (std::shared_ptr<boot::union_type> union_type = type.is_union())
-        {
-            std::set<std::string> field_names;
-            tree union_type_node = make_node(UNION_TYPE);
-
-            for (auto& field : union_type->fields)
-            {
-                if (field_names.find(field.first) != field_names.cend())
-                {
-                    error_at(get_location(&field.second->position()), "repeated field name");
-                    return error_mark_node;
-                }
-                field_names.insert(field.first);
-
-                tree field_type = build_type(*field.second);
-                if (field_type == NULL_TREE || field_type == error_mark_node)
-                {
-                    return field_type;
-                }
-                tree field_declaration = build_field(get_location(&field.second->position()),
-                        union_type_node, field.first, field_type);
-                TYPE_FIELDS(union_type_node) = chainon(TYPE_FIELDS(union_type_node), field_declaration);
-            }
-            layout_type(union_type_node);
-
-            return union_type_node;
-        }
-        else if (std::shared_ptr<boot::procedure_type> procedure_type = type.is_procedure())
-        {
-            tree procedure_type_node = build_procedure_type(*procedure_type);
-            return build_pointer_type_for_mode(procedure_type_node, VOIDmode, true);
-        }
-        return NULL_TREE;
-    }
-
     void generic_visitor::visit(boot::variable_declaration *declaration)
     {
-        tree declaration_type = build_type(declaration->variable_type());
+        declaration->variable_type().accept(this);
-        gcc_assert(declaration_type != NULL_TREE);
 
         location_t declaration_location = get_location(&declaration->position());
         tree declaration_tree = build_decl(declaration_location, VAR_DECL,
-                get_identifier(declaration->identifier.c_str()), declaration_type);
+                get_identifier(declaration->identifier.c_str()), this->current_expression);
         bool result = this->symbol_map->enter(declaration->identifier, declaration_tree);
 
-        if (is_pointer_type(declaration_type))
+        if (is_pointer_type(this->current_expression))
         {
             DECL_INITIAL(declaration_tree) = elna_pointer_nil_node;
         }
+        this->current_expression = NULL_TREE;
         if (!result)
         {
             error_at(declaration_location, "variable '%s' already declared in this scope",
@@ -967,28 +874,30 @@ namespace gcc
 
     void generic_visitor::visit(boot::traits_expression *trait)
     {
-        tree type_expression = build_type(trait->type());
+        trait->type().accept(this);
 
         if (trait->name == "size")
         {
-            this->current_expression = build1(CONVERT_EXPR, elna_word_type_node, size_in_bytes(type_expression));
+            this->current_expression = build1(CONVERT_EXPR, elna_word_type_node,
+                    size_in_bytes(this->current_expression));
         }
         else if (trait->name == "alignment")
         {
-            this->current_expression = build_int_cstu(elna_word_type_node, TYPE_ALIGN_UNIT(type_expression));
+            this->current_expression = build_int_cstu(elna_word_type_node,
+                    TYPE_ALIGN_UNIT(this->current_expression));
         }
-        else if (trait->name == "min" && is_integral_type(type_expression))
+        else if (trait->name == "min" && is_integral_type(this->current_expression))
         {
-            this->current_expression = TYPE_MIN_VALUE(type_expression);
+            this->current_expression = TYPE_MIN_VALUE(this->current_expression);
         }
-        else if (trait->name == "max" && is_integral_type(type_expression))
+        else if (trait->name == "max" && is_integral_type(this->current_expression))
         {
-            this->current_expression = TYPE_MAX_VALUE(type_expression);
+            this->current_expression = TYPE_MAX_VALUE(this->current_expression);
         }
         else
         {
             error_at(get_location(&trait->position()), "type '%s' does not have property '%s'",
-                    print_type(type_expression).c_str(), trait->name.c_str());
+                    print_type(this->current_expression).c_str(), trait->name.c_str());
             this->current_expression = error_mark_node;
         }
     }
@@ -1175,8 +1084,10 @@ namespace gcc
         }
     }
 
-    void generic_visitor::visit_return(boot::expression *const return_expression)
+    void generic_visitor::visit(boot::return_statement *statement)
     {
+        boot::expression *return_expression = statement->return_expression();
+
         if (return_expression == nullptr)
         {
             return;
@@ -1190,5 +1101,117 @@ namespace gcc
 
         this->current_expression = NULL_TREE;
     }
+
+    void generic_visitor::visit(boot::primitive_type_expression *type)
+    {
+        tree symbol = this->lookup(type->base_name());
+
+        if (symbol == NULL_TREE && TYPE_P(symbol))
+        {
+            error_at(get_location(&type->position()),
+                    "type '%s' not declared", type->base_name().c_str());
+
+            this->current_expression = error_mark_node;
+        }
+        else
+        {
+            this->current_expression = symbol;
+        }
+    }
+
+    void generic_visitor::visit(boot::array_type_expression *type)
+    {
+        tree lower_bound = build_int_cst_type(integer_type_node, 0);
+        tree upper_bound = build_int_cst_type(integer_type_node, type->size);
+        type->base().accept(this);
+
+        if (this->current_expression != NULL_TREE && this->current_expression != error_mark_node)
+        {
+            tree range_type = build_range_type(integer_type_node, lower_bound, upper_bound);
+
+            this->current_expression = build_array_type(this->current_expression, range_type);
+        }
+    }
+
+    void generic_visitor::visit(boot::pointer_type_expression *type)
+    {
+        type->base().accept(this);
+
+        if (this->current_expression != NULL_TREE && this->current_expression != error_mark_node)
+        {
+            this->current_expression = build_pointer_type_for_mode(this->current_expression, VOIDmode, true);
+        }
+    }
+
+    void generic_visitor::visit(boot::record_type_expression *type)
+    {
+        std::set<std::string> field_names;
+        tree record_type_node = make_node(RECORD_TYPE);
+
+        for (auto& field : type->fields)
+        {
+            if (field_names.find(field.first) != field_names.cend())
+            {
+                error_at(get_location(&field.second->position()), "repeated field name");
+                this->current_expression = error_mark_node;
+                return;
+            }
+            field_names.insert(field.first);
+
+            field.second->accept(this);
+            if (this->current_expression == NULL_TREE || this->current_expression == error_mark_node)
+            {
+                return;
+            }
+            tree field_declaration = build_field(get_location(&field.second->position()),
+                    record_type_node, field.first, this->current_expression);
+            TYPE_FIELDS(record_type_node) = chainon(TYPE_FIELDS(record_type_node), field_declaration);
+        }
+        layout_type(record_type_node);
+
+        this->current_expression = record_type_node;
+    }
+
+    void generic_visitor::visit(boot::union_type_expression *type)
+    {
+        std::set<std::string> field_names;
+        tree union_type_node = make_node(UNION_TYPE);
+
+        for (auto& field : type->fields)
+        {
+            if (field_names.find(field.first) != field_names.cend())
+            {
+                error_at(get_location(&field.second->position()), "repeated field name");
+                this->current_expression = error_mark_node;
+                return;
+            }
+            field_names.insert(field.first);
+
+            field.second->accept(this);
+            if (this->current_expression == NULL_TREE || this->current_expression == error_mark_node)
+            {
+                return;
+            }
+            tree field_declaration = build_field(get_location(&field.second->position()),
+                    union_type_node, field.first, this->current_expression);
+            TYPE_FIELDS(union_type_node) = chainon(TYPE_FIELDS(union_type_node), field_declaration);
+        }
+        layout_type(union_type_node);
+
+        this->current_expression = union_type_node;
+    }
+
+    void generic_visitor::visit(boot::procedure_type_expression *type)
+    {
+        tree procedure_type_node = build_procedure_type(*type);
+        this->current_expression = build_pointer_type_for_mode(procedure_type_node, VOIDmode, true);
+    }
+
+    void generic_visitor::visit(boot::defer_statement *statement)
+    {
+        enter_scope();
+        visit_statements(statement->statements);
+        defer(leave_scope());
+    }
 }
 }

gcc/elna-tree.cc

@@ -91,7 +91,40 @@ namespace gcc
 
     void append_statement(tree statement_tree)
     {
-        append_to_statement_list(statement_tree, &f_binding_level->statement_list);
+        if (!vec_safe_is_empty(f_binding_level->defers))
+        {
+            append_to_statement_list(statement_tree, &f_binding_level->defers->begin()->try_statements);
+        }
+        else
+        {
+            append_to_statement_list(statement_tree, &f_binding_level->statement_list);
+        }
+    }
+
+    void defer(tree statement_tree)
+    {
+        defer_scope new_defer{ statement_tree, alloc_stmt_list() };
+        vec_safe_insert(f_binding_level->defers, 0, new_defer);
+    }
+
+    tree chain_defer()
+    {
+        if (vec_safe_is_empty(f_binding_level->defers))
+        {
+            return f_binding_level->statement_list;
+        }
+        defer_scope *defer_iterator = f_binding_level->defers->begin();
+        tree defer_tree = build2(TRY_FINALLY_EXPR, void_type_node,
+                defer_iterator->try_statements, defer_iterator->defer_block);
+        int i;
+
+        FOR_EACH_VEC_ELT_FROM(*f_binding_level->defers, i, defer_iterator, 1)
+        {
+            append_to_statement_list(defer_tree, &defer_iterator->try_statements);
+            defer_tree = build2(TRY_FINALLY_EXPR, void_type_node,
+                    defer_iterator->try_statements, defer_iterator->defer_block);
+        }
+        return build2(COMPOUND_EXPR, TREE_TYPE(defer_tree), f_binding_level->statement_list, defer_tree);
     }
 
     tree build_field(location_t location, tree record_type, const std::string name, tree type)

gcc/elna1.cc

@@ -30,6 +30,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #include <fstream>
 #include "elna/boot/driver.h"
+#include "elna/boot/semantic.h"
 #include "elna/gcc/elna-tree.h"
 #include "elna/gcc/elna-generic.h"
 #include "elna/gcc/elna-diagnostic.h"
@@ -88,8 +89,10 @@ static void elna_parse_file(const char *filename)
     }
     else
     {
+        elna::boot::name_analysis_visitor name_analysis_visitor{ std::make_shared<elna::boot::symbol_table<>>() };
         elna::gcc::generic_visitor generic_visitor{ std::make_shared<elna::gcc::symbol_table>() };
 
+        name_analysis_visitor.visit(driver.tree.get());
         generic_visitor.visit(driver.tree.get());
     }
     linemap_add(line_table, LC_LEAVE, 0, NULL, 0);

include/elna/boot/ast.h

@@ -63,23 +63,25 @@ namespace boot
     class assign_statement;
     class if_statement;
     class while_statement;
+    class return_statement;
     class traits_expression;
     class block;
     class program;
     class binary_expression;
     class unary_expression;
-    class basic_type;
+    class primitive_type_expression;
-    class array_type;
+    class array_type_expression;
-    class pointer_type;
+    class pointer_type_expression;
-    class record_type;
+    class record_type_expression;
-    class union_type;
+    class union_type_expression;
-    class procedure_type;
+    class procedure_type_expression;
     class variable_expression;
     class array_access_expression;
     class field_access_expression;
     class dereference_expression;
     template<typename T>
     class number_literal;
+    class defer_statement;
 
     /**
      * Interface for AST visitors.
@@ -96,20 +98,22 @@ namespace boot
         virtual void visit(assign_statement *) = 0;
         virtual void visit(if_statement *) = 0;
         virtual void visit(while_statement *) = 0;
+        virtual void visit(return_statement *) = 0;
+        virtual void visit(defer_statement *) = 0;
         virtual void visit(block *) = 0;
         virtual void visit(program *) = 0;
         virtual void visit(binary_expression *) = 0;
         virtual void visit(unary_expression *) = 0;
-        virtual void visit(basic_type *) = 0;
+        virtual void visit(primitive_type_expression *) = 0;
-        virtual void visit(array_type *) = 0;
+        virtual void visit(array_type_expression *) = 0;
-        virtual void visit(pointer_type *) = 0;
+        virtual void visit(pointer_type_expression *) = 0;
-        virtual void visit(record_type *) = 0;
+        virtual void visit(record_type_expression *) = 0;
-        virtual void visit(union_type *) = 0;
+        virtual void visit(union_type_expression *) = 0;
-        virtual void visit(procedure_type *) = 0;
+        virtual void visit(procedure_type_expression *) = 0;
         virtual void visit(variable_expression *) = 0;
         virtual void visit(array_access_expression *) = 0;
-        virtual void visit(field_access_expression *is_field_access) = 0;
+        virtual void visit(field_access_expression *) = 0;
-        virtual void visit(dereference_expression *is_dereference) = 0;
+        virtual void visit(dereference_expression *) = 0;
         virtual void visit(number_literal<std::int32_t> *) = 0;
         virtual void visit(number_literal<std::uint32_t> *) = 0;
         virtual void visit(number_literal<double> *) = 0;
@@ -125,29 +129,31 @@ namespace boot
     struct empty_visitor : parser_visitor
     {
         virtual void visit(variable_declaration *) override;
-        virtual void visit(constant_definition *definition) override;
+        virtual void visit(constant_definition *) override;
-        virtual void visit(procedure_definition *definition) override;
+        virtual void visit(procedure_definition *) override;
-        virtual void visit(type_definition *definition) override;
+        virtual void visit(type_definition *) override;
-        virtual void visit(traits_expression *trait) override;
+        virtual void visit(traits_expression *) override;
-        virtual void visit(procedure_call *call) override;
+        virtual void visit(procedure_call *) override;
-        virtual void visit(cast_expression *expression) override;
+        virtual void visit(cast_expression *) override;
-        virtual void visit(assign_statement *statement) override;
+        virtual void visit(assign_statement *) override;
         virtual void visit(if_statement *) override;
         virtual void visit(while_statement *) override;
-        virtual void visit(block *block) override;
+        virtual void visit(return_statement *) override;
-        virtual void visit(program *program) override;
+        virtual void visit(defer_statement *) override;
-        virtual void visit(binary_expression *expression) override;
+        virtual void visit(block *) override;
-        virtual void visit(unary_expression *expression) override;
+        virtual void visit(program *) override;
-        virtual void visit(basic_type *) override;
+        virtual void visit(binary_expression *) override;
-        virtual void visit(array_type *expression) override;
+        virtual void visit(unary_expression *) override;
-        virtual void visit(pointer_type *) override;
+        virtual void visit(primitive_type_expression *) override;
-        virtual void visit(record_type *expression) override;
+        virtual void visit(array_type_expression *) override;
-        virtual void visit(union_type *expression) override;
+        virtual void visit(pointer_type_expression *) override;
-        virtual void visit(procedure_type *expression) override;
+        virtual void visit(record_type_expression *) override;
+        virtual void visit(union_type_expression *) override;
+        virtual void visit(procedure_type_expression *) override;
         virtual void visit(variable_expression *) override;
-        virtual void visit(array_access_expression *expression) override;
+        virtual void visit(array_access_expression *) override;
-        virtual void visit(field_access_expression *expression) override;
+        virtual void visit(field_access_expression *) override;
-        virtual void visit(dereference_expression *expression) override;
+        virtual void visit(dereference_expression *) override;
         virtual void visit(number_literal<std::int32_t> *) override;
         virtual void visit(number_literal<std::uint32_t> *) override;
         virtual void visit(number_literal<double> *) override;
@@ -208,24 +214,16 @@ namespace boot
     /**
      * Some type expression.
      */
-    class top_type : public node, public std::enable_shared_from_this<top_type>
+    class type_expression : public node, public std::enable_shared_from_this<type_expression>
     {
-    public:
-        virtual std::shared_ptr<basic_type> is_basic();
-        virtual std::shared_ptr<array_type> is_array();
-        virtual std::shared_ptr<pointer_type> is_pointer();
-        virtual std::shared_ptr<record_type> is_record();
-        virtual std::shared_ptr<union_type> is_union();
-        virtual std::shared_ptr<procedure_type> is_procedure();
-
     protected:
-        top_type(const struct position position);
+        type_expression(const struct position position);
     };
 
     /**
      * Expression defining a basic type.
      */
-    class basic_type : public top_type
+    class primitive_type_expression : public type_expression
     {
         const std::string m_name;
 
@@ -234,65 +232,58 @@ namespace boot
          * \param position Source code position.
          * \param name Type name.
          */
-        basic_type(const struct position position, const std::string& name);
+        primitive_type_expression(const struct position position, const std::string& name);
         virtual void accept(parser_visitor *visitor) override;
 
         const std::string& base_name();
-
-        std::shared_ptr<basic_type> is_basic() override;
     };
 
-    class array_type : public top_type
+    class array_type_expression : public type_expression
     {
-        std::shared_ptr<top_type> m_base;
+        std::shared_ptr<type_expression> m_base;
 
     public:
         const std::uint32_t size;
 
-        array_type(const struct position position, std::shared_ptr<top_type> base, const std::uint32_t size);
+        array_type_expression(const struct position position,
+                std::shared_ptr<type_expression> base, const std::uint32_t size);
         virtual void accept(parser_visitor *visitor) override;
 
-        top_type& base();
+        type_expression& base();
-
-        std::shared_ptr<array_type> is_array() override;
     };
 
-    class pointer_type : public top_type
+    class pointer_type_expression : public type_expression
     {
-        std::shared_ptr<top_type> m_base;
+        std::shared_ptr<type_expression> m_base;
 
     public:
-        pointer_type(const struct position position, std::shared_ptr<top_type> base);
+        pointer_type_expression(const struct position position, std::shared_ptr<type_expression> base);
         virtual void accept(parser_visitor *visitor) override;
 
-        top_type& base();
+        type_expression& base();
-
-        std::shared_ptr<pointer_type> is_pointer() override;
     };
 
-    using field_t = std::pair<std::string, std::shared_ptr<top_type>>;
+    using field_t = std::pair<std::string, std::shared_ptr<type_expression>>;
     using fields_t = std::vector<field_t>;
 
-    class record_type : public top_type
+    class record_type_expression : public type_expression
     {
     public:
         fields_t fields;
 
-        record_type(const struct position position, fields_t&& fields);
+        record_type_expression(const struct position position, fields_t&& fields);
 
         virtual void accept(parser_visitor *visitor) override;
-        std::shared_ptr<record_type> is_record() override;
     };
 
-    class union_type : public top_type
+    class union_type_expression : public type_expression
     {
     public:
         fields_t fields;
 
-        union_type(const struct position position, fields_t&& fields);
+        union_type_expression(const struct position position, fields_t&& fields);
 
         virtual void accept(parser_visitor *visitor) override;
-        std::shared_ptr<union_type> is_union() override;
     };
 
     /**
@@ -300,14 +291,14 @@ namespace boot
      */
     class variable_declaration : public definition
     {
-        std::shared_ptr<top_type> m_type;
+        std::shared_ptr<type_expression> m_type;
 
     public:
         variable_declaration(const struct position position, const std::string& identifier,
-                std::shared_ptr<top_type> type, const bool exported = false);
+                std::shared_ptr<type_expression> type, const bool exported = false);
         virtual void accept(parser_visitor *visitor) override;
 
-        top_type& variable_type();
+        type_expression& variable_type();
     };
 
     /**
@@ -352,20 +343,20 @@ namespace boot
     /**
      * Procedure type.
      */
-    class procedure_type : public top_type
+    class procedure_type_expression : public type_expression
     {
     public:
-        const std::shared_ptr<top_type> return_type;
+        const std::shared_ptr<type_expression> return_type;
         const bool no_return;
         std::vector<variable_declaration *> parameters;
 
-        procedure_type(const struct position position, std::shared_ptr<top_type> return_type = nullptr);
+        procedure_type_expression(const struct position position,
-        procedure_type(const struct position position, no_return_t);
+                std::shared_ptr<type_expression> return_type = nullptr);
+        procedure_type_expression(const struct position position, no_return_t);
 
         virtual void accept(parser_visitor *visitor) override;
-        std::shared_ptr<procedure_type> is_procedure() override;
 
-        virtual ~procedure_type() override;
+        virtual ~procedure_type_expression() override;
     };
 
     /**
@@ -373,18 +364,16 @@ namespace boot
      */
     class procedure_definition : public definition
     {
-        std::shared_ptr<procedure_type> m_heading;
+        std::shared_ptr<procedure_type_expression> m_heading;
 
     public:
         block *const body;
-        expression *const returning;
 
         procedure_definition(const struct position position, const std::string& identifier,
-                const bool exported, std::shared_ptr<procedure_type> heading,
+                const bool exported, std::shared_ptr<procedure_type_expression> heading, block *body = nullptr);
-                block *const body = nullptr, expression *const returning = nullptr);
         virtual void accept(parser_visitor *visitor) override;
 
-        procedure_type& heading();
+        procedure_type_expression& heading();
 
         virtual ~procedure_definition() override;
     };
@@ -394,14 +383,14 @@ namespace boot
      */
     class type_definition : public definition
     {
-        std::shared_ptr<top_type> m_body;
+        std::shared_ptr<type_expression> m_body;
 
     public:
         type_definition(const struct position position, const std::string& identifier,
-                const bool exported, std::shared_ptr<top_type> expression);
+                const bool exported, std::shared_ptr<type_expression> expression);
         virtual void accept(parser_visitor *visitor) override;
 
-        top_type& body();
+        type_expression& body();
     };
 
     /**
@@ -409,14 +398,14 @@ namespace boot
      */
     class cast_expression : public expression
     {
-        std::shared_ptr<top_type> m_target;
+        std::shared_ptr<type_expression> m_target;
         expression *m_value;
 
     public:
-        cast_expression(const struct position position, std::shared_ptr<top_type> target, expression *value);
+        cast_expression(const struct position position, std::shared_ptr<type_expression> target, expression *value);
         virtual void accept(parser_visitor *visitor) override;
 
-        top_type& target();
+        type_expression& target();
         expression& value();
 
         virtual ~cast_expression() override;
@@ -424,15 +413,16 @@ namespace boot
 
     class traits_expression : public expression
     {
-        std::shared_ptr<top_type> m_type;
+        std::shared_ptr<type_expression> m_type;
 
     public:
         const std::string name;
 
-        traits_expression(const struct position position, const std::string& name, std::shared_ptr<top_type> type);
+        traits_expression(const struct position position, const std::string& name,
+                std::shared_ptr<type_expression> type);
         virtual void accept(parser_visitor *visitor) override;
 
-        top_type& type();
+        type_expression& type();
     };
 
     /**
@@ -452,6 +442,19 @@ namespace boot
         virtual ~conditional_statements();
     };
 
+    class return_statement : public statement
+    {
+        expression *m_return_expression{ nullptr };
+
+    public:
+        return_statement(const struct position position, expression *return_expression);
+        virtual void accept(parser_visitor *visitor) override;
+
+        expression *return_expression();
+
+        virtual ~return_statement() override;
+    };
+
     class designator_expression : public expression
     {
     public:
@@ -644,6 +647,17 @@ namespace boot
         }
     };
 
+    class defer_statement : public statement
+    {
+    public:
+        std::vector<statement *> statements;
+
+        defer_statement(const struct position position);
+        virtual void accept(parser_visitor *visitor) override;
+
+        virtual ~defer_statement() override;
+    };
+
     class binary_expression : public expression
     {
         expression *m_lhs;

include/elna/boot/semantic.h

@@ -0,0 +1,37 @@
+/* Semantic analysis visitors.
+   Copyright (C) 2025 Free Software Foundation, Inc.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#pragma once
+
+#include "elna/boot/ast.h"
+#include "elna/boot/symbol.h"
+
+namespace elna
+{
+namespace boot
+{
+    class name_analysis_visitor : public empty_visitor
+    {
+        std::shared_ptr<symbol_table<>> table;
+
+    public:
+        name_analysis_visitor(std::shared_ptr<symbol_table<>> table);
+
+        void visit(program *program) override;
+    };
+}
+}

include/elna/boot/symbol.h

@@ -26,10 +26,27 @@ namespace elna
 {
 namespace boot
 {
+    class type
+    {
+        virtual ~type() = 0;
+
+    protected:
+        type() = default;
+    };
+
+    class info
+    {
+    public:
+        virtual ~info() = 0;
+
+    protected:
+        info() = default;
+    };
+
     /**
      * Symbol table.
      */
-    template<typename T, T nothing>
+    template<typename T = std::shared_ptr<info>, typename U = std::nullptr_t, U nothing = nullptr>
     class symbol_table
     {
     public:

include/elna/gcc/elna-generic.h

@@ -40,8 +40,7 @@ namespace gcc
         std::shared_ptr<symbol_table> symbol_map;
 
         tree build_label_decl(const char *name, location_t loc);
-        tree build_procedure_type(boot::procedure_type& type);
+        tree build_procedure_type(boot::procedure_type_expression& type);
-        tree build_type(boot::top_type& type);
 
         void enter_scope();
         tree leave_scope();
@@ -61,7 +60,6 @@ namespace gcc
         void build_record_call(location_t call_location,
                 tree symbol, const std::vector<boot::expression *>& arguments);
         void visit_statements(const std::vector<boot::statement *>& statements);
-        void visit_return(boot::expression *const return_expression);
 
     public:
         generic_visitor(std::shared_ptr<symbol_table> symbol_table);
@@ -91,6 +89,14 @@ namespace gcc
         void visit(boot::assign_statement *statement) override;
         void visit(boot::if_statement *statement) override;
         void visit(boot::while_statement *statement) override;
+        void visit(boot::primitive_type_expression *type) override;
+        void visit(boot::array_type_expression *type) override;
+        void visit(boot::pointer_type_expression *type) override;
+        void visit(boot::record_type_expression *type) override;
+        void visit(boot::union_type_expression *type) override;
+        void visit(boot::procedure_type_expression *type) override;
+        void visit(boot::return_statement *statement) override;
+        void visit(boot::defer_statement *statement) override;
     };
 }
 }

include/elna/gcc/elna-tree.h

@@ -33,7 +33,7 @@ namespace elna
 {
 namespace gcc
 {
-    using symbol_table = boot::symbol_table<tree, NULL_TREE>;
+    using symbol_table = boot::symbol_table<tree, tree, NULL_TREE>;
 
     bool is_pointer_type(tree type);
     bool is_integral_type(tree type);
@@ -72,6 +72,8 @@ namespace gcc
     bool is_assignable_from(tree assignee, tree assignment);
 
     void append_statement(tree statement_tree);
+    void defer(tree statement_tree);
+    tree chain_defer();
 
     tree do_pointer_arithmetic(boot::binary_operator binary_operator, tree left, tree right);
     tree build_binary_operation(bool condition, boot::binary_expression *expression,

include/elna/gcc/elna1.h

@@ -58,6 +58,12 @@ struct GTY (()) lang_decl
 {
 };
 
+struct GTY (()) defer_scope
+{
+    tree defer_block;
+    tree try_statements;
+};
+
 struct GTY ((chain_next ("%h.level_chain"))) binding_level
 {
     // A block chain is needed to call defer statements beloning to each block.
@@ -68,6 +74,9 @@ struct GTY ((chain_next ("%h.level_chain"))) binding_level
 
     // Statements before the first defer has been seen.
     tree statement_list;
+
+    // Defer statement coupled with statements following it.
+    vec<defer_scope, va_gc> *defers;
 };
 
 struct GTY (()) language_function

source.elna

@@ -140,6 +140,7 @@ proc exit(code: Int) -> !; extern
   Standard procedures.
 *)
 proc reallocarray(ptr: ^Byte, n: Word, size: Word) -> ^Byte;
+begin
   return realloc(ptr, n * size)
 end
 
@@ -197,26 +198,32 @@ begin
 end
 
 proc is_digit(c: Char) -> Bool;
+begin
   return cast(c: Int) >= cast('0': Int) and cast(c: Int) <= cast('9': Int)
 end
 
 proc is_alpha(c: Char) -> Bool;
+begin
   return cast(c: Int) >= cast('A': Int) and cast(c: Int) <= cast('z': Int)
 end
 
 proc is_alnum(c: Char) -> Bool;
+begin
   return is_digit(c) or is_alpha(c)
 end
 
 proc is_space(c: Char) -> Bool;
+begin
   return c = ' ' or c = '\n' or c = '\t'
 end
 
 proc substring(string: String, start: Word, count: Word) -> String;
+begin
   return String(string.ptr + start, count)
 end
 
 proc open_substring(string: String, start: Word) -> String;
+begin
   return substring(string, start, string.length - start)
 end
 
@@ -270,6 +277,7 @@ end
 *)
 
 proc make_position() -> Position;
+begin
   return Position(1u, 1u)
 end
 
@@ -285,7 +293,7 @@ begin
     result^.handle := file_handle;
     result^.size := 0u;
     result^.index := 1u
-  end
+  end;
   return result
 end
 
@@ -344,7 +352,7 @@ begin
   if source_file^.index > source_file^.size then
     source_file^.size := fread(cast(@source_file^.buffer: ^Byte), 1u, 1024u, source_file^.handle);
 	source_file^.index := 1u
-  end
+  end;
 
   return source_file^.size = 0u
 end
@@ -368,10 +376,12 @@ begin
 end
 
 proc source_code_empty(source_code: ^SourceCode) -> Bool;
+begin
   return source_code^.empty(source_code^.input)
 end
 
 proc source_code_head(source_code: SourceCode) -> Char;
+begin
   return source_code.head(source_code.input)
 end
 
@@ -388,6 +398,7 @@ begin
 end
 
 proc source_code_expect(source_code: ^SourceCode, expected: Char) -> Bool;
+begin
   return not source_code_empty(source_code) and source_code_head(source_code^) = expected
 end
 
@@ -402,6 +413,7 @@ begin
 end
 
 proc is_ident(char: Char) -> Bool;
+begin
   return is_alnum(char) or char = '_'
 end
 
@@ -433,7 +445,7 @@ begin
 	  trailing := 0u
 	end;
     source_code_advance(source_code)
-  end
+  end;
 
   return trailing = 2u
 end
@@ -456,7 +468,7 @@ begin
   end;
   if successful then
     source_code_advance(source_code)
-  end
+  end;
   return successful
 end
 
@@ -481,7 +493,7 @@ begin
     source_code_advance(source_code)
   else
     is_valid := false
-  end
+  end;
   return is_valid
 end
 
@@ -710,7 +722,7 @@ begin
   else
 	current_token.kind := TOKEN_IDENTIFIER;
 	current_token.value.string := string_dup(token_content)
-  end
+  end;
 
   return current_token
 end
@@ -887,7 +899,7 @@ begin
 	  write_c(first_char);
 	  write_s("\".\n")
 	end
-  end
+  end;
 
   return tokens
 end
@@ -904,7 +916,7 @@ begin
   result^.syntax_tree := false;
   result^.input := nil;
 
-  while i < argc and result <> nil do
+  while i < argc do
     parameter := argv + i;
 
     if strcmp(parameter^, "--tokenize\0".ptr) = 0 then
@@ -920,15 +932,15 @@ begin
       write_z(parameter^);
       write_s(".\n");
 
-      result := nil
+      return nil
     end;
 
     i := i + 1
   end;
-  if result <> nil and result^.input = nil then
+  if result^.input = nil then
     write_s("Fatal error: no input files.\n");
-	result := nil
+	return nil
-  end
+  end;
 
   return result
 end
@@ -969,7 +981,7 @@ begin
     if command_line^.tokenize then
       print_tokens(tokens, tokens_size)
     end
-  end
+  end;
   return return_code
 end