statements builders start

include/statement_builders.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "statement_nodes.hpp"
+#include "tree_sitter_wrapper.hpp"
+
+namespace builders {
+
+// IN PROGRESS: return type, etc.
+void build_source_file(parser::ParseTree::Node parse_node,
+                       nodes::ExpressionStorage &expression_storage,
+                       nodes::TypeStorage &type_storage);
+
+// IN PROGRESS: return type, etc.
+void build_statement(parser::ParseTree::Node parse_node,
+                     nodes::ExpressionStorage &expression_storage,
+                     nodes::TypeStorage &type_storage);
+
+nodes::Import build_import(parser::ParseTree::Node parse_node,
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage);
+
+nodes::Constraint build_constraint(parser::ParseTree::Node parse_node,
+                                   nodes::ExpressionStorage &expression_storage,
+                                   nodes::TypeStorage &type_storage);
+
+nodes::TypeDefinition
+build_type_definition(parser::ParseTree::Node parse_node,
+                      nodes::ExpressionStorage &expression_storage,
+                      nodes::TypeStorage &type_storage);
+
+nodes::FunctionDefinition
+build_function_definition(parser::ParseTree::Node parse_node,
+                          nodes::ExpressionStorage &expression_storage,
+                          nodes::TypeStorage &type_storage);
+
+nodes::TypeclassDefinition
+build_typeclass_definition(parser::ParseTree::Node parse_node,
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage);
+
+} // namespace builders

src/expression_builders.cpp

@@ -495,7 +495,11 @@ build_name_expression(parser::ParseTree::Node parse_node,
                             type_storage, arguments);
 
   return nodes::NameExpression(
-      build_node(parse_node), build_simple_name(name_node),
+      build_node(parse_node),
+      tokens::string_to_type(name_node.get_type()) ==
+              tokens::Type::ARGUMENT_NAME_IDENTIFIER
+          ? build_argument_name(name_node)
+          : build_simple_name(name_node),
       std::move(arguments),
       prefix_node.has_value() ? build_type(prefix_node.value(), type_storage)
                               : std::optional<nodes::TypeProxy>(),
@@ -526,12 +530,15 @@ nodes::Lambda build_lambda(parser::ParseTree::Node parse_node,
                            nodes::TypeStorage &type_storage) {
   std::vector<nodes::Identifier> arguments;
 
-  auto current_node = parse_node.nth_named_child(0);
-  while (tokens::string_to_type(current_node.get_type()) ==
-         tokens::Type::ARGUMENT_NAME_IDENTIFIER) {
+  auto current_node = parse_node.nth_child(1); // next to '\\'
+
+  while (current_node.is_named()) { // until _do_
     arguments.emplace_back(build_argument_name(parse_node));
-    current_node = current_node.next_named_sibling();
+    current_node = current_node.next_sibling();
   }
+
+  current_node = current_node.next_named_sibling();
+
   return nodes::Lambda(
       build_node(parse_node), std::move(arguments),
       build_expression(current_node, expression_storage, type_storage));

src/statement_builders.cpp

@@ -0,0 +1,54 @@
+#include "../include/statement_builders.hpp"
+
+#include "statement_nodes.hpp"
+#include "tree_sitter_wrapper.hpp"
+
+namespace builders {
+
+// IN PROGRESS: return type, etc.
+void build_source_file(parser::ParseTree::Node parse_node,
+                       nodes::ExpressionStorage &expression_storage,
+                       nodes::TypeStorage &type_storage) {} // IN PROCESS
+
+// IN PROGRESS: return type, etc.
+void build_statement(parser::ParseTree::Node parse_node,
+                     nodes::ExpressionStorage &expression_storage,
+                     nodes::TypeStorage &type_storage) {} // IN PROCESS
+
+// ('::' | 'import') simple_name ('=' simple_name)? (':' identifier*)?
+nodes::Import build_import(parser::ParseTree::Node parse_node,
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage) {} // IN PROCESS
+
+// '?' expression
+nodes::Constraint build_constraint(parser::ParseTree::Node parse_node,
+                                   nodes::ExpressionStorage &expression_storage,
+                                   nodes::TypeStorage &type_storage) {
+} // IN PROCESS
+
+// definition_info? annotation_info* '^'? simple_type (argument_type* '='
+// (variant_type | tuple_type))? ('{' function_definition* '}' | ';')
+nodes::TypeDefinition
+build_type_definition(parser::ParseTree::Node parse_node,
+                      nodes::ExpressionStorage &expression_storage,
+                      nodes::TypeStorage &type_storage) {} // IN PROCESS
+
+// TODO: make references possible only at one place at once
+
+// definition_info? annotation_info*  (constraint ';')* (simple_name | '('
+// operator ')') (annotation? _reference_? argument_name '?'?)* (: (annotation?
+// _reference_ type)+)?
+// ('=' (block | expression ';') | ';')
+nodes::FunctionDefinition
+build_function_definition(parser::ParseTree::Node parse_node,
+                          nodes::ExpressionStorage &expression_storage,
+                          nodes::TypeStorage &type_storage) {} // IN PROCESS
+
+// definition_info? annotation_info* typeclass_identifier (':'
+// typeclass_identifier+)? ('{' function_definition* '}' | ';')
+nodes::TypeclassDefinition
+build_typeclass_definition(parser::ParseTree::Node parse_node,
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage) {} // IN PROCESS
+
+} // namespace builders