Move record constructor type into the braces

3 files changed, 20 insertions, 43 deletions

diff --git a/boot/ast.cc b/boot/ast.cc
index dc643fe..d698cd4 100644
--- a/boot/ast.cc
+++ b/boot/ast.cc
@@ -423,6 +423,7 @@ namespace elna::boot
 
     void walking_visitor::visit(record_constructor_expression *expression)
     {
+        expression->record_type().accept(this);
         for (const field_initializer& initializer : expression->field_initializers)
         {
             initializer.value().accept(this);
@@ -844,36 +845,29 @@ namespace elna::boot
     }
 
     record_constructor_expression::record_constructor_expression(const source_position position,
-            identifier&& type_name,
-            std::vector<field_initializer>&& field_initializers)
-        : node(position), type_name(std::move(type_name)), field_initializers(std::move(field_initializers))
+            type_expression *record_type, std::vector<field_initializer>&& field_initializers)
+        : node(position), m_record_type(record_type), field_initializers(std::move(field_initializers))
     {
     }
 
-    record_constructor_expression::record_constructor_expression(const source_position position,
-            identifier&& type_name, std::vector<type_expression *>&& arguments,
-            std::vector<field_initializer>&& field_initializers)
-        : node(position), type_name(std::move(type_name)),
-        field_initializers(std::move(field_initializers)), arguments(std::move(arguments))
+    void record_constructor_expression::accept(parser_visitor *visitor)
     {
+        visitor->visit(this);
     }
 
-    record_constructor_expression::~record_constructor_expression()
+    record_constructor_expression *record_constructor_expression::is_record_constructor()
     {
-        for (const type_expression *argument : this->arguments)
-        {
-            delete argument;
-        }
+        return this;
     }
 
-    void record_constructor_expression::accept(parser_visitor *visitor)
+    type_expression& record_constructor_expression::record_type()
     {
-        visitor->visit(this);
+        return *this->m_record_type;
     }
 
-    record_constructor_expression *record_constructor_expression::is_record_constructor()
+    record_constructor_expression::~record_constructor_expression()
     {
-        return this;
+        delete this->m_record_type;
     }
 
     array_constructor_expression::array_constructor_expression(const source_position position,
diff --git a/boot/name_analysis.cc b/boot/name_analysis.cc
index ff5f6bc..5ad2a75 100644
--- a/boot/name_analysis.cc
+++ b/boot/name_analysis.cc
@@ -918,21 +918,8 @@ namespace elna::boot
 
     void resolving_visitor::visit(record_constructor_expression *expression)
     {
-        if (const auto type_symbol = this->bag.lookup(expression->type_name.name()))
-        {
-            if (const auto type_info = type_symbol->is_type())
-            {
-                expression->type_decoration = expression->arguments.empty()
-                    ? type_info->symbol
-                    : type(std::make_shared<instantiated_type>(type_info->symbol,
-                                resolve_arguments(expression->arguments)));
-            }
-        }
-        else
-        {
-            add_error<symbol_declaration_error>(expression->type_name.position(),
-                    expression->type_name.name(), symbol_declaration_error::kind::undeclared_type);
-        }
+        expression->type_decoration = resolve_type(expression->record_type());
+
         for (const field_initializer& initializer : expression->field_initializers)
         {
             initializer.value().accept(this);
diff --git a/boot/parser.yy b/boot/parser.yy
index e8c3590..f416d57 100644
--- a/boot/parser.yy
+++ b/boot/parser.yy
@@ -424,14 +424,9 @@ simple_expression:
         }
     | call_expression { $$ = $1; }
     | "(" expression ")" { $$ = $2; }
-    | name_reference "{" field_initializers "}"
+    | "{" type_expression field_initializers "}"
         {
-            boot::named_expression *reference = $1;
-
-            $$ = new boot::record_constructor_expression(boot::make_position(@$),
-                    boot::identifier(reference->name, reference->position()),
-                    std::move(reference->arguments), $3);
-            delete reference;
+            $$ = new boot::record_constructor_expression(boot::make_position(@$), $2, $3);
         }
     | "[" required_expressions "]"
         {
@@ -644,12 +639,13 @@ field_declarations:
 field_initializer:
     identifier ":" expression { $$ = std::make_unique<boot::field_initializer>(std::move(*$1), $3); }
 field_initializers:
-    field_initializer "," field_initializers
+    ";" field_initializer { $$.push_back(std::move(*$2)); }
+    | field_initializers "," field_initializer
         {
-            $$ = $3;
-            $$.emplace($$.cbegin(), std::move(*$1));
+            $$ = $1;
+            $$.push_back(std::move(*$3));
         }
-    | field_initializer { $$.push_back(std::move(*$1)); }
+    | %empty {}
 array_type_expression:
     "[" expression "]" type_expression
         { $$ = new boot::array_type_expression(boot::make_position(@$), $4, $2); }