type builders

deps/tree-sitter-lang

@@ -1 +1 @@
-Subproject commit 39f31b901dd3f77f33ad7d047ac78d2b94d7ca1d
+Subproject commit df305457c82a7a9d6e9791ae12a75c7cd16fe663

include/expression_builders.hpp

@@ -9,69 +9,85 @@ namespace builders {
 
 nodes::ExpressionProxy
 build_expression(parser::ParseTree::Node parse_node,
-                 nodes::ExpressionStorage& expression_storage);
+                 nodes::ExpressionStorage &expression_storage,
+                 nodes::TypeStorage &type_storage);
 
 nodes::Match build_match(parser::ParseTree::Node parse_node,
-                         nodes::ExpressionStorage& expression_storage);
+                         nodes::ExpressionStorage &expression_storage,
+                         nodes::TypeStorage &type_storage);
 
 nodes::Condition build_condition(parser::ParseTree::Node parse_node,
-                                 nodes::ExpressionStorage& expression_storage);
+                                 nodes::ExpressionStorage &expression_storage,
+                                 nodes::TypeStorage &type_storage);
 
 nodes::Loop build_loop(parser::ParseTree::Node parse_node,
-                       nodes::ExpressionStorage& expression_storage);
+                       nodes::ExpressionStorage &expression_storage,
+                       nodes::TypeStorage &type_storage);
 
 // --- operators
 
 nodes::NameExpression
 build_comma_expression(parser::ParseTree::Node parse_node,
-                       nodes::ExpressionStorage& expression_storage);
+                       nodes::ExpressionStorage &expression_storage,
+                       nodes::TypeStorage &type_storage);
 
 nodes::NameExpression
 build_operator_expression(parser::ParseTree::Node parse_node,
-                          nodes::ExpressionStorage& expression_storage);
+                          nodes::ExpressionStorage &expression_storage,
+                          nodes::TypeStorage &type_storage);
 
 // --- continers
 
 nodes::Container build_block(parser::ParseTree::Node parse_node,
-                             nodes::ExpressionStorage &expression_storage);
+                             nodes::ExpressionStorage &expression_storage,
+                             nodes::TypeStorage &type_storage);
 
 nodes::Container build_array(parser::ParseTree::Node parse_node,
-                             nodes::ExpressionStorage& expression_storage);
+                             nodes::ExpressionStorage &expression_storage,
+                             nodes::TypeStorage &type_storage);
 
 // --- modifiers
 
 nodes::Return build_return(parser::ParseTree::Node parse_node,
-                           nodes::ExpressionStorage& expression_storage);
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage);
 
 nodes::NameDefinition build_name_definition(parser::ParseTree::Node parse_node);
 
 nodes::Access build_array_access(parser::ParseTree::Node parse_node,
-                                 nodes::ExpressionStorage& expression_storage);
+                                 nodes::ExpressionStorage &expression_storage,
+                                 nodes::TypeStorage &type_storage);
 
 nodes::Access build_tuple_access(parser::ParseTree::Node parse_node,
-                                 nodes::ExpressionStorage& expression_storage);
+                                 nodes::ExpressionStorage &expression_storage,
+                                 nodes::TypeStorage &type_storage);
 
 nodes::LoopControl build_loop_control(parser::ParseTree::Node parse_node);
 
 nodes::ModifierExpression
 build_reference_expression(parser::ParseTree::Node parse_node,
-                           nodes::ExpressionStorage& expression_storage);
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage);
 
 nodes::ModifierExpression
 build_suffix_expression(parser::ParseTree::Node parse_node,
-                        nodes::ExpressionStorage& expression_storage);
+                        nodes::ExpressionStorage &expression_storage,
+                        nodes::TypeStorage &type_storage);
 
 // --- other
 
 nodes::NameExpression
 build_name_expression(parser::ParseTree::Node parse_node,
-                      nodes::ExpressionStorage& expression_storage);
+                      nodes::ExpressionStorage &expression_storage,
+                      nodes::TypeStorage &type_storage);
 
 nodes::Constructor
 build_constructor(parser::ParseTree::Node parse_node,
-                  nodes::ExpressionStorage& expression_storage);
+                  nodes::ExpressionStorage &expression_storage,
+                  nodes::TypeStorage &type_storage);
 
 nodes::Lambda build_lambda(parser::ParseTree::Node parse_node,
-                           nodes::ExpressionStorage& expression_storage);
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage);
 
 } // namespace builders

include/type_builders.hpp

@@ -5,11 +5,8 @@
 
 namespace builders {
 
-// nodes::Type build_type(parser::ParseTree::Node parse_node,
+nodes::TypeProxy build_type(parser::ParseTree::Node parse_node,
-//                        nodes::TypeStorage &type_storage);
+                            nodes::TypeStorage &type_storage);
-
-nodes::TypeProxy build_type_proxy(parser::ParseTree::Node parse_node,
-                                  nodes::TypeStorage &type_storage);
 
 nodes::TupleType build_tuple_type(parser::ParseTree::Node parse_node,
                                   nodes::TypeStorage &type_storage);

src/expression_builders.cpp

@@ -5,67 +5,70 @@
 #include "error_handling.hpp"
 #include "expression_nodes.hpp"
 #include "tokens.hpp"
+#include "type_builders.hpp"
 #include "type_nodes.hpp"
-#include <memory>
 
 namespace builders {
 
 nodes::ExpressionProxy
 build_expression(parser::ParseTree::Node parse_node,
-                 nodes::ExpressionStorage &expression_storage) {
+                 nodes::ExpressionStorage &expression_storage,
+                 nodes::TypeStorage &type_storage) {
   tokens::Type type = tokens::string_to_type(parse_node.get_type());
 
   switch (type) {
   // --- flow control
   case tokens::Type::MATCH:
-    return expression_storage.add_expression(
+    return expression_storage.add_expression(nodes::Expression(
-        nodes::Expression(build_match(parse_node, expression_storage)));
+        build_match(parse_node, expression_storage, type_storage)));
   case tokens::Type::CONDITION:
-    return expression_storage.add_expression(
+    return expression_storage.add_expression(nodes::Expression(
-        nodes::Expression(build_condition(parse_node, expression_storage)));
+        build_condition(parse_node, expression_storage, type_storage)));
   case tokens::Type::LOOP:
-    return expression_storage.add_expression(
+    return expression_storage.add_expression(nodes::Expression(
-        nodes::Expression(build_loop(parse_node, expression_storage)));
+        build_loop(parse_node, expression_storage, type_storage)));
   // --- operators
   case tokens::Type::COMMA_EXPRESSION:
     return expression_storage.add_expression(nodes::Expression(
-        build_comma_expression(parse_node, expression_storage)));
+        build_comma_expression(parse_node, expression_storage, type_storage)));
   case tokens::Type::OPERATOR_EXPRESSION:
-    return expression_storage.add_expression(nodes::Expression(
+    return expression_storage.add_expression(
-        build_operator_expression(parse_node, expression_storage)));
+        nodes::Expression(build_operator_expression(
+            parse_node, expression_storage, type_storage)));
   // --- containers
   case tokens::Type::BLOCK:
-    return expression_storage.add_expression(
+    return expression_storage.add_expression(nodes::Expression(
-        nodes::Expression(build_block(parse_node, expression_storage)));
+        build_block(parse_node, expression_storage, type_storage)));
   case tokens::Type::ARRAY:
-    return expression_storage.add_expression(
+    return expression_storage.add_expression(nodes::Expression(
-        nodes::Expression(build_array(parse_node, expression_storage)));
+        build_array(parse_node, expression_storage, type_storage)));
   // --- modifiers
   case tokens::Type::RETURN:
-    return expression_storage.add_expression(
+    return expression_storage.add_expression(nodes::Expression(
-        nodes::Expression(build_return(parse_node, expression_storage)));
+        build_return(parse_node, expression_storage, type_storage)));
   case tokens::Type::NAME_DEFINITION:
     return expression_storage.add_expression(
         nodes::Expression(build_name_definition(parse_node)));
   case tokens::Type::ARRAY_ACCESS:
-    return expression_storage.add_expression(
+    return expression_storage.add_expression(nodes::Expression(
-        nodes::Expression(build_array_access(parse_node, expression_storage)));
+        build_array_access(parse_node, expression_storage, type_storage)));
   case tokens::Type::TUPLE_ACCESS:
-    return expression_storage.add_expression(
+    return expression_storage.add_expression(nodes::Expression(
-        nodes::Expression(build_tuple_access(parse_node, expression_storage)));
+        build_tuple_access(parse_node, expression_storage, type_storage)));
   case tokens::Type::LOOP_CONTROL:
     return expression_storage.add_expression(
         nodes::Expression(build_loop_control(parse_node)));
   case tokens::Type::REFERENCE_EXPRESSION:
-    return expression_storage.add_expression(nodes::Expression(
+    return expression_storage.add_expression(
-        build_reference_expression(parse_node, expression_storage)));
+        nodes::Expression(build_reference_expression(
+            parse_node, expression_storage, type_storage)));
   case tokens::Type::SUFFIX_EXPRESSION:
     return expression_storage.add_expression(nodes::Expression(
-        build_suffix_expression(parse_node, expression_storage)));
+        build_suffix_expression(parse_node, expression_storage, type_storage)));
   // --- other
   case tokens::Type::NAME_EXPRESSION:
     return expression_storage.add_expression(nodes::Expression(
-        build_name_expression(parse_node, expression_storage)));
+        build_name_expression(parse_node, expression_storage, type_storage)));
   case tokens::Type::ARGUMENT_NAME_IDENTIFIER:
     return expression_storage.add_expression(
         nodes::Expression(nodes::NameExpression(
@@ -75,11 +78,11 @@ build_expression(parser::ParseTree::Node parse_node,
         nodes::Expression(nodes::NameExpression(
             build_node(parse_node), build_simple_name(parse_node))));
   case tokens::Type::CONSTRUCTOR:
-    return expression_storage.add_expression(
+    return expression_storage.add_expression(nodes::Expression(
-        nodes::Expression(build_constructor(parse_node, expression_storage)));
+        build_constructor(parse_node, expression_storage, type_storage)));
   case tokens::Type::LAMBDA:
-    return expression_storage.add_expression(
+    return expression_storage.add_expression(nodes::Expression(
-        nodes::Expression(build_lambda(parse_node, expression_storage)));
+        build_lambda(parse_node, expression_storage, type_storage)));
   // --- literals
   case tokens::Type::FLOAT_NUMBER_LITERAL:
     return expression_storage.add_expression(
@@ -114,7 +117,8 @@ build_expression(parser::ParseTree::Node parse_node,
 
 // (':=' | '=:') expression (('??' | 'if') expression)? (_do_ expression)?
 nodes::Match::Case build_case(parser::ParseTree::Node parse_node,
-                              nodes::ExpressionStorage &expression_storage) {
+                              nodes::ExpressionStorage &expression_storage,
+                              nodes::TypeStorage &type_storage) {
   std::string case_type = parse_node.nth_child(0).get_value();
 
   std::optional<parser::ParseTree::Node> condition_node;
@@ -138,36 +142,41 @@ nodes::Match::Case build_case(parser::ParseTree::Node parse_node,
       build_node(parse_node),
       case_type == ":=" ? nodes::Match::Case::PATTERN_VALUE
                         : nodes::Match::Case::VALUE_PATTERN,
-      build_expression(parse_node.nth_named_child(0), expression_storage),
+      build_expression(parse_node.nth_named_child(0), expression_storage,
+                       type_storage),
       condition_node.has_value()
-          ? build_expression(condition_node.value(), expression_storage)
+          ? build_expression(condition_node.value(), expression_storage,
+                             type_storage)
           : std::optional<nodes::ExpressionProxy>(),
       expression_node.has_value()
-          ? build_expression(expression_node.value(), expression_storage)
+          ? build_expression(expression_node.value(), expression_storage,
+                             type_storage)
           : std::optional<nodes::ExpressionProxy>());
 }
 
 // expression case+
 nodes::Match build_match(parser::ParseTree::Node parse_node,
-                         nodes::ExpressionStorage &expression_storage) {
+                         nodes::ExpressionStorage &expression_storage,
+                         nodes::TypeStorage &type_storage) {
   std::vector<nodes::Match::Case> cases;
 
   auto current_node = parse_node.nth_named_child(1);
   while (!current_node.is_null()) {
-    cases.push_back(build_case(current_node, expression_storage));
+    cases.push_back(build_case(current_node, expression_storage, type_storage));
     current_node = current_node.next_named_sibling();
   }
 
-  return nodes::Match(
+  return nodes::Match(build_node(parse_node),
-      build_node(parse_node),
+                      build_expression(parse_node.nth_named_child(0),
-      build_expression(parse_node.nth_named_child(0), expression_storage),
+                                       expression_storage, type_storage),
-      std::move(cases));
+                      std::move(cases));
 }
 
 // ('??' | 'if') expression _do_ expression (('!!' | 'elif') expression _do_
 // expression)* (('!!=>', 'else') expression)?
 nodes::Condition build_condition(parser::ParseTree::Node parse_node,
-                                 nodes::ExpressionStorage &expression_storage) {
+                                 nodes::ExpressionStorage &expression_storage,
+                                 nodes::TypeStorage &type_storage) {
   size_t named_child_count = parse_node.named_child_count();
 
   std::vector<std::pair<nodes::ExpressionProxy, nodes::ExpressionProxy>> cases;
@@ -176,8 +185,9 @@ nodes::Condition build_condition(parser::ParseTree::Node parse_node,
   auto next_node = current_node.next_named_sibling();
 
   while (!current_node.is_null() && !next_node.is_null()) {
-    cases.push_back({build_expression(current_node, expression_storage),
+    cases.push_back(
-                     build_expression(next_node, expression_storage)});
+        {build_expression(current_node, expression_storage, type_storage),
+         build_expression(next_node, expression_storage, type_storage)});
     current_node = next_node.next_named_sibling();
     if (current_node.is_null()) {
       break;
@@ -189,30 +199,34 @@ nodes::Condition build_condition(parser::ParseTree::Node parse_node,
       build_node(parse_node), std::move(cases),
       named_child_count % 2 == 1
           ? build_expression(parse_node.nth_named_child(named_child_count - 1),
-                             expression_storage)
+                             expression_storage, type_storage)
           : std::optional<nodes::ExpressionProxy>());
 }
 
 // ('@' | 'for') (expression | expression ':' expression)? _do_ expression
 nodes::Loop build_loop(parser::ParseTree::Node parse_node,
-                       nodes::ExpressionStorage &expression_storage) {
+                       nodes::ExpressionStorage &expression_storage,
+                       nodes::TypeStorage &type_storage) {
   size_t named_child_count = parse_node.named_child_count();
 
   if (named_child_count == 1) { // body
-    return nodes::Loop(
+    return nodes::Loop(build_node(parse_node),
-        build_node(parse_node),
+                       build_expression(parse_node.nth_named_child(0),
-        build_expression(parse_node.nth_named_child(0), expression_storage));
+                                        expression_storage, type_storage));
   } else if (named_child_count == 2) { // condition, body
-    return nodes::Loop(
+    return nodes::Loop(build_node(parse_node),
-        build_node(parse_node),
+                       build_expression(parse_node.nth_named_child(0),
-        build_expression(parse_node.nth_named_child(0), expression_storage),
+                                        expression_storage, type_storage),
-        build_expression(parse_node.nth_named_child(1), expression_storage));
+                       build_expression(parse_node.nth_named_child(1),
+                                        expression_storage, type_storage));
   } else if (named_child_count == 3) { // variable, interval, body
-    return nodes::Loop(
+    return nodes::Loop(build_node(parse_node),
-        build_node(parse_node),
+                       build_expression(parse_node.nth_named_child(0),
-        build_expression(parse_node.nth_named_child(0), expression_storage),
+                                        expression_storage, type_storage),
-        build_expression(parse_node.nth_named_child(1), expression_storage),
+                       build_expression(parse_node.nth_named_child(1),
-        build_expression(parse_node.nth_named_child(2), expression_storage));
+                                        expression_storage, type_storage),
+                       build_expression(parse_node.nth_named_child(2),
+                                        expression_storage, type_storage));
   } else {
     error_handling::handle_parsing_error(
         "Unexprected named expression amount in loop", parse_node);
@@ -227,17 +241,18 @@ nodes::Loop build_loop(parser::ParseTree::Node parse_node,
 // expression ',' expression
 nodes::NameExpression
 build_comma_expression(parser::ParseTree::Node parse_node,
-                       nodes::ExpressionStorage &expression_storage) {
+                       nodes::ExpressionStorage &expression_storage,
+                       nodes::TypeStorage &type_storage) {
   std::vector<std::pair<std::optional<std::string>, nodes::ExpressionProxy>>
       arguments;
 
-  arguments.emplace_back(
+  arguments.emplace_back(std::nullopt,
-      std::nullopt,
+                         build_expression(parse_node.nth_named_child(0),
-      build_expression(parse_node.nth_named_child(0), expression_storage));
+                                          expression_storage, type_storage));
 
-  arguments.emplace_back(
+  arguments.emplace_back(std::nullopt,
-      std::nullopt,
+                         build_expression(parse_node.nth_named_child(1),
-      build_expression(parse_node.nth_named_child(1), expression_storage));
+                                          expression_storage, type_storage));
 
   return nodes::NameExpression(
       build_node(parse_node),
@@ -250,19 +265,20 @@ build_comma_expression(parser::ParseTree::Node parse_node,
 // expression operator expression
 nodes::NameExpression
 build_operator_expression(parser::ParseTree::Node parse_node,
-                          nodes::ExpressionStorage &expression_storage) {
+                          nodes::ExpressionStorage &expression_storage,
+                          nodes::TypeStorage &type_storage) {
   auto name_node = parse_node.child_by_field_name("name");
 
   std::vector<std::pair<std::optional<std::string>, nodes::ExpressionProxy>>
       arguments;
 
-  arguments.emplace_back(
+  arguments.emplace_back(std::nullopt,
-      std::nullopt,
+                         build_expression(name_node.previous_named_sibling(),
-      build_expression(name_node.previous_named_sibling(), expression_storage));
+                                          expression_storage, type_storage));
 
-  arguments.emplace_back(
+  arguments.emplace_back(std::nullopt,
-      std::nullopt,
+                         build_expression(name_node.next_named_sibling(),
-      build_expression(name_node.next_named_sibling(), expression_storage));
+                                          expression_storage, type_storage));
 
   return nodes::NameExpression(build_node(parse_node),
                                build_operator(name_node), std::move(arguments),
@@ -274,13 +290,15 @@ build_operator_expression(parser::ParseTree::Node parse_node,
 nodes::Container
 build_container(parser::ParseTree::Node parse_node,
                 nodes::ExpressionStorage &expression_storage,
+                nodes::TypeStorage &type_storage,
                 nodes::Container::ContainerType container_type) {
   std::vector<nodes::ExpressionProxy> expressions;
 
   auto current_node = parse_node.nth_named_child(0).next_named_sibling();
 
   while (!current_node.is_null()) {
-    expressions.push_back(build_expression(current_node, expression_storage));
+    expressions.push_back(
+        build_expression(current_node, expression_storage, type_storage));
     current_node = current_node.next_named_sibling();
   }
 
@@ -290,15 +308,17 @@ build_container(parser::ParseTree::Node parse_node,
 
 // '{' (expression ';')* '}'
 nodes::Container build_block(parser::ParseTree::Node parse_node,
-                             nodes::ExpressionStorage &expression_storage) {
+                             nodes::ExpressionStorage &expression_storage,
-  return build_container(parse_node, expression_storage,
+                             nodes::TypeStorage &type_storage) {
+  return build_container(parse_node, expression_storage, type_storage,
                          nodes::Container::BLOCK);
 }
 
 // '[[' expression+ ']]'
 nodes::Container build_array(parser::ParseTree::Node parse_node,
-                             nodes::ExpressionStorage &expression_storage) {
+                             nodes::ExpressionStorage &expression_storage,
-  return build_container(parse_node, expression_storage,
+                             nodes::TypeStorage &type_storage) {
+  return build_container(parse_node, expression_storage, type_storage,
                          nodes::Container::ARRAY);
 }
 
@@ -306,13 +326,15 @@ nodes::Container build_array(parser::ParseTree::Node parse_node,
 
 // ('return' | 'bring') expression
 nodes::Return build_return(parser::ParseTree::Node parse_node,
-                           nodes::ExpressionStorage &expression_storage) {
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage) {
   std::string modifier = parse_node.nth_child(0).get_value();
 
-  return nodes::Return(
+  return nodes::Return(build_node(parse_node),
-      build_node(parse_node),
+                       modifier == "return" ? nodes::Return::RETURN
-      modifier == "return" ? nodes::Return::RETURN : nodes::Return::BRING,
+                                            : nodes::Return::BRING,
-      build_expression(parse_node.nth_named_child(0), expression_storage));
+                       build_expression(parse_node.nth_named_child(0),
+                                        expression_storage, type_storage));
 }
 
 // _var_let_ (simple_name_identifier | placeholder)
@@ -334,19 +356,23 @@ build_name_definition(parser::ParseTree::Node parse_node) {
 
 // expression '[' expression ']'
 nodes::Access build_array_access(parser::ParseTree::Node parse_node,
-                                 nodes::ExpressionStorage &expression_storage) {
+                                 nodes::ExpressionStorage &expression_storage,
-  return nodes::Access(
+                                 nodes::TypeStorage &type_storage) {
-      build_node(parse_node), nodes::Access::ARRAY,
+  return nodes::Access(build_node(parse_node), nodes::Access::ARRAY,
-      build_expression(parse_node.nth_named_child(0), expression_storage),
+                       build_expression(parse_node.nth_named_child(0),
-      build_expression(parse_node.nth_named_child(1), expression_storage));
+                                        expression_storage, type_storage),
+                       build_expression(parse_node.nth_named_child(1),
+                                        expression_storage, type_storage));
 }
 
 // expression '.' number_literal
 nodes::Access build_tuple_access(parser::ParseTree::Node parse_node,
-                                 nodes::ExpressionStorage &expression_storage) {
+                                 nodes::ExpressionStorage &expression_storage,
+                                 nodes::TypeStorage &type_storage) {
   return nodes::Access(
       build_node(parse_node), nodes::Access::TUPLE,
-      build_expression(parse_node.nth_named_child(0), expression_storage),
+      build_expression(parse_node.nth_named_child(0), expression_storage,
+                       type_storage),
       expression_storage.add_expression(nodes::Expression(
           build_number_literal(parse_node.nth_named_child(1)))));
 }
@@ -382,26 +408,31 @@ string_to_modifier(const std::string &modifier) {
 nodes::ModifierExpression
 build_modifier_expression(parser::ParseTree::Node parse_node,
                           nodes::ExpressionStorage &expression_storage,
+                          nodes::TypeStorage &type_storage,
                           size_t modifier_position) {
   std::string modifier = parse_node.nth_child(modifier_position).get_value();
 
   return nodes::ModifierExpression(
       build_node(parse_node), string_to_modifier(modifier),
-      build_expression(parse_node.nth_named_child(0), expression_storage));
+      build_expression(parse_node.nth_named_child(0), expression_storage,
+                       type_storage));
 }
 
 // _reference_ expression
 nodes::ModifierExpression
 build_reference_expression(parser::ParseTree::Node parse_node,
-                           nodes::ExpressionStorage &expression_storage) {
+                           nodes::ExpressionStorage &expression_storage,
-  return build_modifier_expression(parse_node, expression_storage, 0);
+                           nodes::TypeStorage &type_storage) {
+  return build_modifier_expression(parse_node, expression_storage, type_storage,
+                                   0);
 }
 
 // expression ('?' | '!')
 nodes::ModifierExpression
 build_suffix_expression(parser::ParseTree::Node parse_node,
-                        nodes::ExpressionStorage &expression_storage) {
+                        nodes::ExpressionStorage &expression_storage,
-  return build_modifier_expression(parse_node, expression_storage,
+                        nodes::TypeStorage &type_storage) {
+  return build_modifier_expression(parse_node, expression_storage, type_storage,
                                    parse_node.child_count() - 1);
 }
 
@@ -410,6 +441,7 @@ build_suffix_expression(parser::ParseTree::Node parse_node,
 void build_arguments_until_end(
     parser::ParseTree::Node first_parse_node,
     nodes::ExpressionStorage &expression_storage,
+    nodes::TypeStorage &type_storage,
     std::vector<std::pair<std::optional<std::string>, nodes::ExpressionProxy>>
         &arguments) {
 
@@ -423,7 +455,7 @@ void build_arguments_until_end(
     } else {
       arguments.emplace_back(
           std::move(last_annotation),
-          build_expression(current_node, expression_storage));
+          build_expression(current_node, expression_storage, type_storage));
       last_annotation = std::nullopt;
     }
     current_node = current_node.next_named_sibling();
@@ -434,7 +466,8 @@ void build_arguments_until_end(
 // ')') (annotation? expression)*
 nodes::NameExpression
 build_name_expression(parser::ParseTree::Node parse_node,
-                      nodes::ExpressionStorage &expression_storage) {
+                      nodes::ExpressionStorage &expression_storage,
+                      nodes::TypeStorage &type_storage) {
   std::vector<std::pair<std::optional<std::string>, nodes::ExpressionProxy>>
       arguments;
 
@@ -444,45 +477,53 @@ build_name_expression(parser::ParseTree::Node parse_node,
 
   auto name_node = parse_node.child_by_field_name("name");
 
-  auto type_node = name_node.previous_named_sibling();
+  std::optional<parser::ParseTree::Node> prefix_node;
 
-  if (!type_node.is_null()) {
+  auto current_node = name_node.previous_named_sibling();
-    if (tokens::string_to_type(type_node.get_type()) == tokens::Type::TYPE) {
+  if (!current_node.is_null()) {
-      prefix = build_type(type_node);
+    if (tokens::string_to_type(current_node.get_type()) == tokens::Type::TYPE) {
+      prefix_node = current_node;
     } else {
       is_point_call = true;
-      arguments.emplace_back(std::nullopt,
+      arguments.emplace_back(
-                             build_expression(type_node, expression_storage));
+          std::nullopt,
+          build_expression(current_node, expression_storage, type_storage));
     }
   }
 
   build_arguments_until_end(name_node.next_named_sibling(), expression_storage,
-                            arguments);
+                            type_storage, arguments);
 
   return nodes::NameExpression(
       build_node(parse_node), build_simple_name(name_node),
-      std::move(arguments), std::move(prefix), is_point_call);
+      std::move(arguments),
-} // IN PROGRESS
+      prefix_node.has_value() ? build_type(prefix_node.value(), type_storage)
+                              : std::optional<nodes::TypeProxy>(),
+      is_point_call);
+}
 
 // type (annotation? expression)*
 nodes::Constructor
 build_constructor(parser::ParseTree::Node parse_node,
-                  nodes::ExpressionStorage &expression_storage) {
+                  nodes::ExpressionStorage &expression_storage,
+                  nodes::TypeStorage &type_storage) {
   std::vector<std::pair<std::optional<std::string>, nodes::ExpressionProxy>>
       arguments;
 
   build_arguments_until_end(
       parse_node.child_by_field_name("type").next_named_sibling(),
-      expression_storage, arguments);
+      expression_storage, type_storage, arguments);
 
-  return nodes::Constructor(build_node(parse_node),
+  return nodes::Constructor(
-                            build_type(parse_node.child_by_field_name("type")),
+      build_node(parse_node),
-                            std::move(arguments));
+      build_type(parse_node.child_by_field_name("type"), type_storage),
+      std::move(arguments));
 }
 
 // '\\' argument_name* _do_ expression
 nodes::Lambda build_lambda(parser::ParseTree::Node parse_node,
-                           nodes::ExpressionStorage &expression_storage) {
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage) {
   std::vector<nodes::Identifier> arguments;
 
   auto current_node = parse_node.nth_named_child(0);
@@ -491,8 +532,9 @@ nodes::Lambda build_lambda(parser::ParseTree::Node parse_node,
     arguments.emplace_back(build_argument_name(parse_node));
     current_node = current_node.next_named_sibling();
   }
-  return nodes::Lambda(build_node(parse_node), std::move(arguments),
+  return nodes::Lambda(
-                       build_expression(current_node, expression_storage));
+      build_node(parse_node), std::move(arguments),
+      build_expression(current_node, expression_storage, type_storage));
 }
 
 } // namespace builders

src/type_builders.cpp

@@ -1,17 +1,72 @@
 #include "../include/type_builders.hpp"
+#include "basic_builders.hpp"
+#include "tokens.hpp"
 
 namespace builders {
 
-// nodes::Type build_type(parser::ParseTree::Node parse_node,
+// '^'? type_identifer '?'? ('[' type+ ']')?
-//                        nodes::TypeStorage &type_storage);
+nodes::TypeProxy build_type(parser::ParseTree::Node parse_node,
+                            nodes::TypeStorage &type_storage) {
+  std::vector<nodes::TypeProxy> parameters;
 
-nodes::TypeProxy build_type_proxy(parser::ParseTree::Node parse_node,
+  auto name_node = parse_node.child_by_field_name("name");
-                                  nodes::TypeStorage &type_storage);
 
+  auto current_node = parse_node.nth_child(0);
+  bool is_on_heap = !current_node.is_null() && current_node.get_value() == "^";
+
+  current_node = name_node.next_sibling();
+  bool is_optional = !current_node.is_null() && current_node.get_value() == "?";
+
+  current_node = name_node.next_named_sibling();
+  while (!current_node.is_null()) {
+    parameters.push_back(build_type(current_node, type_storage));
+    current_node = name_node.next_named_sibling();
+  }
+
+  return type_storage.add_type(
+      nodes::Type(build_node(parse_node),
+                  tokens::string_to_type(name_node.get_type()) ==
+                          tokens::Type::ARGUMENT_TYPE_IDENTIFIER
+                      ? build_argument_type(name_node)
+                      : build_simple_type(name_node),
+                  std::move(parameters), is_on_heap, is_optional));
+}
+
+// '&'? annotation? type ('&' annotation? type)*
 nodes::TupleType build_tuple_type(parser::ParseTree::Node parse_node,
-                                  nodes::TypeStorage &type_storage);
+                                  nodes::TypeStorage &type_storage) {
+  std::vector<std::pair<std::optional<std::string>, nodes::TypeProxy>> fields;
 
+  auto current_node = parse_node.nth_named_child(0);
+
+  std::optional<std::string> last_annotation;
+  while (!current_node.is_null()) {
+    if (tokens::string_to_type(current_node.get_type()) ==
+        tokens::Type::ANNOTATION_IDENTIFIER) {
+      last_annotation = build_annotation(current_node);
+    } else {
+      fields.emplace_back(std::move(last_annotation),
+                          build_type(current_node, type_storage));
+      last_annotation = std::nullopt;
+    }
+    current_node = current_node.next_named_sibling();
+  }
+
+  return nodes::TupleType(build_node(parse_node), std::move(fields));
+}
+
+// '|'? tuple_type ('|' tuple_type)+
 nodes::VariantType build_variant_type(parser::ParseTree::Node parse_node,
-                                      nodes::TypeStorage &type_storage);
+                                      nodes::TypeStorage &type_storage) {
+  std::vector<nodes::TupleType> constructors;
+
+  auto current_node = parse_node.nth_named_child(0);
+  while (!current_node.is_null()) {
+    constructors.push_back(build_tuple_type(current_node, type_storage));
+    current_node = current_node.next_named_sibling();
+  }
+
+  return nodes::VariantType(build_node(parse_node), std::move(constructors));
+}
 
 } // namespace builders