diff --git a/boot/semantic.cc b/boot/semantic.cc
index d1b73c2..d29771a 100644
--- a/boot/semantic.cc
+++ b/boot/semantic.cc
@@ -15,6 +15,8 @@ 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 <set>
+
 #include "elna/boot/semantic.h"
 
 namespace elna
@@ -52,7 +54,8 @@ namespace boot
     {
         for (type_definition *const type : program->types)
         {
-            if (!this->unresolved.insert({ type->identifier, std::make_shared<alias_type>() }).second)
+            if (!this->unresolved.insert({ type->identifier, std::make_shared<alias_type>(type->identifier) }).second
+                    || this->symbols->contains(type->identifier))
             {
                 add_error<already_declared_error>(type->identifier, this->input_file, type->position());
             }
@@ -61,6 +64,11 @@ namespace boot
         {
             type->accept(this);
         }
+        for (auto& unresolved : this->unresolved)
+        {
+            auto info = std::make_shared<type_info>(type_info(type(unresolved.second)));
+            this->symbols->enter(std::move(unresolved.first), info);
+        }
     }
 
     void declaration_visitor::visit(type_definition *definition)
@@ -79,7 +87,7 @@ namespace boot
         {
             this->current_type = type(unresolved_alias->second);
         }
-        else if (auto from_symbol_table = this->symbols.lookup(type_expression->name))
+        else if (auto from_symbol_table = this->symbols->lookup(type_expression->name))
         {
             this->current_type = from_symbol_table->is_type()->symbol;
         }
@@ -102,32 +110,54 @@ namespace boot
         this->current_type = type(std::make_shared<array_type>(this->current_type, type_expression->size));
     }
 
+    bool declaration_visitor::build_composite_type(const std::vector<field_declaration>& declarations,
+            std::vector<type_field>& fields)
+    {
+        std::set<std::string> field_names;
+
+        for (auto& field : declarations)
+        {
+            if (field_names.find(field.first) != field_names.cend())
+            {
+                add_error<already_declared_error>(field.first, this->input_file, field.second->position());
+                this->current_type = type();
+                return false;
+            }
+            field.second->accept(this);
+            if (!this->current_type.empty())
+            {
+                fields.push_back({ field.first, type(this->current_type) });
+            }
+        }
+        return true;
+    }
+
     void declaration_visitor::visit(record_type_expression *type_expression)
     {
         auto type_definition = std::make_shared<record_type>();
 
-        for (auto& field : type_expression->fields)
+        if (build_composite_type(type_expression->fields, type_definition->fields))
         {
-            field.second->accept(this);
-            if (!this->current_type.empty())
-            {
-                type_definition->fields.push_back({ field.first, type(this->current_type) });
-            }
+            this->current_type = type(type_definition);
+        }
+        else
+        {
+            this->current_type = type();
         }
-        this->current_type = type(type_definition);
     }
 
     void declaration_visitor::visit(union_type_expression *type_expression)
     {
         auto type_definition = std::make_shared<union_type>();
 
-        for (auto& field : type_expression->fields)
+        if (build_composite_type(type_expression->fields, type_definition->fields))
         {
-            field.second->accept(this);
-
-            type_definition->fields.push_back({ field.first, type(this->current_type) });
+            this->current_type = type(type_definition);
+        }
+        else
+        {
+            this->current_type = type();
         }
-        this->current_type = type(type_definition);
     }
 
     void declaration_visitor::visit(procedure_type_expression *type_expression)
diff --git a/boot/symbol.cc b/boot/symbol.cc
index c1de6e6..0391579 100644
--- a/boot/symbol.cc
+++ b/boot/symbol.cc
@@ -247,6 +247,11 @@ namespace boot
         return tag == type_tag::empty;
     }
 
+    alias_type::alias_type(const std::string& name)
+        : name(name), reference()
+    {
+    }
+
     pointer_type::pointer_type(type base)
         : base(base)
     {
diff --git a/gcc/Make-lang.in b/gcc/Make-lang.in
index a9fed82..3159853 100644
--- a/gcc/Make-lang.in
+++ b/gcc/Make-lang.in
@@ -136,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++14
+ELNA_CXXFLAGS = -std=c++17
 
 elna/%.o: elna/boot/%.cc elna/generated/parser.hh elna/generated/location.hh
 	$(COMPILE) $(ELNA_CXXFLAGS) $(ELNA_INCLUDES) $<
diff --git a/gcc/elna-generic.cc b/gcc/elna-generic.cc
index db39118..6906815 100644
--- a/gcc/elna-generic.cc
+++ b/gcc/elna-generic.cc
@@ -38,11 +38,15 @@ namespace elna
 {
 namespace gcc
 {
-    static tree get_inner_alias(std::shared_ptr<symbol_table> symbol_table, const boot::type& type)
+    tree handle_symbol(const std::string& symbol_name, const boot::type& type,
+            std::shared_ptr<boot::symbol_table> from, std::shared_ptr<symbol_table> to);
+
+    tree get_inner_alias(const boot::type& type,
+            std::shared_ptr<boot::symbol_table> from, std::shared_ptr<symbol_table> to)
     {
         if (auto reference = type.get<boot::primitive_type>())
         {
-            return symbol_table->lookup(reference->identifier);
+            return to->lookup(reference->identifier);
         }
         else if (auto reference = type.get<boot::record_type>())
         {
@@ -54,15 +58,36 @@ namespace gcc
         }
         else if (auto reference = type.get<boot::pointer_type>())
         {
-            return build_pointer_type_for_mode(get_inner_alias(symbol_table, reference->base), VOIDmode, true);
+            return build_pointer_type_for_mode(get_inner_alias(reference->base, from, to), VOIDmode, true);
+        }
+        else if (auto reference = type.get<boot::array_type>())
+        {
+            tree lower_bound = build_int_cst_type(integer_type_node, 0);
+            tree upper_bound = build_int_cst_type(integer_type_node, reference->size);
+            tree range_type = build_range_type(integer_type_node, lower_bound, upper_bound);
+
+            return build_array_type(get_inner_alias(reference->base, from, to), range_type);
         }
         else if (auto reference = type.get<boot::alias_type>())
         {
-            return get_inner_alias(symbol_table, reference->reference);
+            return handle_symbol(reference->name, reference->reference, from, to);
         }
         return error_mark_node;
     }
 
+    tree handle_symbol(const std::string& symbol_name, const boot::type& type,
+            std::shared_ptr<boot::symbol_table> from, std::shared_ptr<symbol_table> to)
+    {
+        auto looked_up = to->lookup(symbol_name);
+
+        if (looked_up == NULL_TREE)
+        {
+            looked_up = get_inner_alias(type, from, to);
+            to->enter(symbol_name, looked_up);
+        }
+        return looked_up;
+    }
+
     std::deque<std::unique_ptr<boot::error>> do_semantic_analysis(const char *path,
             std::unique_ptr<boot::program>& ast, std::shared_ptr<symbol_table> symbols)
     {
@@ -73,10 +98,13 @@ namespace gcc
 
         if (declaration_visitor.errors().empty())
         {
-            for (auto unresolved : declaration_visitor.unresolved)
+            for (auto& [symbol_name, symbol_info] : *info_table)
             {
-                auto inner_alias = get_inner_alias(symbols, boot::type(unresolved.second));
-                symbols->enter(unresolved.first, inner_alias);
+                handle_symbol(symbol_name, symbol_info->is_type()->symbol, info_table, symbols);
+            }
+            for (auto& [symbol_name, symbol_info] : *info_table)
+            {
+                // printf("%s\n", symbol_name.c_str());
             }
         }
         return std::move(declaration_visitor.errors());
@@ -1154,7 +1182,7 @@ namespace gcc
     void generic_visitor::visit(boot::record_type_expression *type)
     {
         std::set<std::string> field_names;
-        tree record_type_node = this->current_expression == NULL_TREE
+        tree composite_type_node = this->current_expression == NULL_TREE
             ? make_node(RECORD_TYPE)
             : this->current_expression;
 
@@ -1174,19 +1202,19 @@ namespace gcc
                 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);
+                    composite_type_node, field.first, this->current_expression);
+            TYPE_FIELDS(composite_type_node) = chainon(TYPE_FIELDS(composite_type_node), field_declaration);
             this->current_expression = NULL_TREE;
         }
-        layout_type(record_type_node);
+        layout_type(composite_type_node);
 
-        this->current_expression = record_type_node;
+        this->current_expression = composite_type_node;
     }
 
     void generic_visitor::visit(boot::union_type_expression *type)
     {
         std::set<std::string> field_names;
-        tree union_type_node = this->current_expression == NULL_TREE
+        tree composite_type_node = this->current_expression == NULL_TREE
             ? make_node(UNION_TYPE)
             : this->current_expression;
 
@@ -1206,13 +1234,13 @@ namespace gcc
                 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);
+                    composite_type_node, field.first, this->current_expression);
+            TYPE_FIELDS(composite_type_node) = chainon(TYPE_FIELDS(composite_type_node), field_declaration);
             this->current_expression = NULL_TREE;
         }
-        layout_type(union_type_node);
+        layout_type(composite_type_node);
 
-        this->current_expression = union_type_node;
+        this->current_expression = composite_type_node;
     }
 
     void generic_visitor::visit(boot::procedure_type_expression *type)
diff --git a/include/elna/boot/semantic.h b/include/elna/boot/semantic.h
index afbf353..c17287e 100644
--- a/include/elna/boot/semantic.h
+++ b/include/elna/boot/semantic.h
@@ -51,11 +51,13 @@ namespace boot
     class declaration_visitor final : public empty_visitor, public error_container
     {
         type current_type;
-        symbol_table symbols;
-
-    public:
+        std::shared_ptr<symbol_table> symbols;
         std::unordered_map<std::string, std::shared_ptr<alias_type>> unresolved;
 
+        bool build_composite_type(const std::vector<field_declaration>& declarations,
+                std::vector<type_field>& fields);
+
+    public:
         explicit declaration_visitor(const char *path, std::shared_ptr<symbol_table> symbols);
 
         void visit(primitive_type_expression *type_expression) override;
diff --git a/include/elna/boot/symbol.h b/include/elna/boot/symbol.h
index 7e45f2f..404cf30 100644
--- a/include/elna/boot/symbol.h
+++ b/include/elna/boot/symbol.h
@@ -85,7 +85,10 @@ namespace boot
 
     struct alias_type
     {
+        const std::string name;
         type reference;
+
+        explicit alias_type(const std::string& name);
     };
 
     struct pointer_type
@@ -173,22 +176,30 @@ namespace boot
 
         iterator begin()
         {
-            return entries.begin();
+            return this->entries.begin();
         }
 
         iterator end()
         {
-            return entries.end();
+            return this->entries.end();
         }
 
         const_iterator cbegin() const
         {
-            return entries.cbegin();
+            return this->entries.cbegin();
         }
 
         const_iterator cend() const
         {
-            return entries.cend();
+            return this->entries.cend();
+        }
+
+        /**
+         * \return Symbol count in the current scope.
+         */
+        std::size_t size() const
+        {
+            return this->entries.size();
         }
 
         /**
@@ -213,6 +224,15 @@ namespace boot
             return nothing;
         }
 
+        /**
+         * \param name Symbol name.
+         * \return Whether the table contains a symbol with the given name.
+         */
+        bool contains(const std::string& name)
+        {
+            return lookup(name) != nothing;
+        }
+
         /**
          * Registers new symbol.
          *