folder structure refactoring

include/builders/basic_builders.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "basic_nodes.hpp"
+#include "tree_sitter_wrapper.hpp"
+
+namespace builders {
+
+namespace utils {
+
+inline bool is_suffix_modifier(nodes::Modifier modifier) {
+  return modifier == nodes::Modifier::OPTIONAL ||
+         modifier == nodes::Modifier::RESULT;
+}
+
+} // namespace utils
+
+// returns Modifier::NONE for incorrecnt input
+nodes::Modifier build_modifier(parser::ParseTree::Node parser_node);
+
+nodes::Node build_node(parser::ParseTree::Node parser_node);
+
+// --- literals
+
+nodes::Literal build_float_number_literal(parser::ParseTree::Node parser_node);
+
+nodes::Literal build_number_literal(parser::ParseTree::Node parser_node);
+
+nodes::Literal build_string_literal(parser::ParseTree::Node parser_node);
+
+nodes::Literal build_char_literal(parser::ParseTree::Node parser_node);
+
+nodes::Literal build_bool_literal(parser::ParseTree::Node parser_node);
+
+nodes::Literal build_unit_literal(parser::ParseTree::Node parser_node);
+
+nodes::Literal build_null_literal(parser::ParseTree::Node parser_node);
+
+// --- identifiers
+
+nodes::Identifier build_identifier(parser::ParseTree::Node parser_node);
+
+nodes::Identifier build_simple_name(parser::ParseTree::Node parser_node);
+
+nodes::Identifier build_simple_type(parser::ParseTree::Node parser_node);
+
+nodes::Identifier build_typeclass(parser::ParseTree::Node parser_node);
+
+nodes::Identifier build_argument_name(parser::ParseTree::Node parser_node);
+
+nodes::Identifier build_argument_type(parser::ParseTree::Node parser_node);
+
+// Annotations are used as strings
+std::string build_annotation(parser::ParseTree::Node parser_node);
+
+nodes::Identifier build_operator(parser::ParseTree::Node parser_node);
+
+nodes::Identifier build_placeholder(parser::ParseTree::Node parser_node);
+
+// --- extra
+
+nodes::Extra build_extra(parser::ParseTree::Node parser_node);
+
+// --- empty lines
+
+nodes::EmptyLines build_empty_lines(parser::ParseTree::Node parser_node);
+
+} // namespace builders

include/builders/doc_builders.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "doc_nodes.hpp"
+#include "tree_sitter_wrapper.hpp"
+
+#include <unordered_set>
+#include <vector>
+
+namespace builders {
+
+nodes::SymbolDocs build_symbol_docs(
+    std::optional<parser::ParseTree::Node> description_parser_node,
+    const std::vector<parser::ParseTree::Node> &annotation_parser_nodes = {},
+    const std::unordered_set<std::string> &annotations = {});
+
+} // namespace builders

include/builders/expression_builders.hpp

@@ -0,0 +1,94 @@
+#pragma once
+
+#include "expression_nodes.hpp"
+#include "tree_sitter_wrapper.hpp"
+
+namespace builders {
+
+// --- flow control
+
+nodes::ExpressionProxy
+build_expression(parser::ParseTree::Node parser_node,
+                 nodes::ExpressionStorage &expression_storage,
+                 nodes::TypeStorage &type_storage);
+
+nodes::Match build_match(parser::ParseTree::Node parser_node,
+                         nodes::ExpressionStorage &expression_storage,
+                         nodes::TypeStorage &type_storage);
+
+nodes::Condition build_condition(parser::ParseTree::Node parser_node,
+                                 nodes::ExpressionStorage &expression_storage,
+                                 nodes::TypeStorage &type_storage);
+
+nodes::Loop build_loop(parser::ParseTree::Node parser_node,
+                       nodes::ExpressionStorage &expression_storage,
+                       nodes::TypeStorage &type_storage);
+
+// --- operators
+
+nodes::NameExpression
+build_comma_expression(parser::ParseTree::Node parser_node,
+                       nodes::ExpressionStorage &expression_storage,
+                       nodes::TypeStorage &type_storage);
+
+nodes::NameExpression
+build_operator_expression(parser::ParseTree::Node parser_node,
+                          nodes::ExpressionStorage &expression_storage,
+                          nodes::TypeStorage &type_storage);
+
+// --- continers
+
+nodes::Container build_block(parser::ParseTree::Node parser_node,
+                             nodes::ExpressionStorage &expression_storage,
+                             nodes::TypeStorage &type_storage);
+
+nodes::Container build_array(parser::ParseTree::Node parser_node,
+                             nodes::ExpressionStorage &expression_storage,
+                             nodes::TypeStorage &type_storage);
+
+// --- modifiers
+
+nodes::Return build_return(parser::ParseTree::Node parser_node,
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage);
+
+nodes::NameDefinition
+build_name_definition(parser::ParseTree::Node parser_node);
+
+nodes::Access build_array_access(parser::ParseTree::Node parser_node,
+                                 nodes::ExpressionStorage &expression_storage,
+                                 nodes::TypeStorage &type_storage);
+
+nodes::Access build_tuple_access(parser::ParseTree::Node parser_node,
+                                 nodes::ExpressionStorage &expression_storage,
+                                 nodes::TypeStorage &type_storage);
+
+nodes::LoopControl build_loop_control(parser::ParseTree::Node parser_node);
+
+nodes::ModifierExpression
+build_reference_expression(parser::ParseTree::Node parser_node,
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage);
+
+nodes::ModifierExpression
+build_suffix_expression(parser::ParseTree::Node parser_node,
+                        nodes::ExpressionStorage &expression_storage,
+                        nodes::TypeStorage &type_storage);
+
+// --- other
+
+nodes::NameExpression
+build_name_expression(parser::ParseTree::Node parser_node,
+                      nodes::ExpressionStorage &expression_storage,
+                      nodes::TypeStorage &type_storage);
+
+nodes::Constructor
+build_constructor(parser::ParseTree::Node parser_node,
+                  nodes::ExpressionStorage &expression_storage,
+                  nodes::TypeStorage &type_storage);
+
+nodes::Lambda build_lambda(parser::ParseTree::Node parser_node,
+                           nodes::ExpressionStorage &expression_storage,
+                           nodes::TypeStorage &type_storage);
+
+} // namespace builders

include/builders/statement_builders.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "name_tree.hpp"
+#include "statement_nodes.hpp"
+#include "tree_sitter_wrapper.hpp"
+
+#include <vector>
+
+namespace builders {
+
+// statements (copies of statements  are in name_tree) returned to print /
+// translate them in required order
+std::vector<nodes::Statement>
+build_source_file(parser::ParseTree::Node parser_node,
+                  nodes::ExpressionStorage &expression_storage,
+                  nodes::TypeStorage &type_storage, names::NameTree &name_tree);
+
+// copy of statement inserted into name_tree
+nodes::Statement
+build_statement(parser::ParseTree::Node parser_node,
+                std::optional<nodes::Identifier> &previous_defined_type_name,
+                nodes::ExpressionStorage &expression_storage,
+                nodes::TypeStorage &type_storage, names::NameTree &name_tree);
+
+nodes::Import build_import(parser::ParseTree::Node parser_node);
+
+nodes::Constraint build_constraint(parser::ParseTree::Node parser_node,
+                                   nodes::ExpressionStorage &expression_storage,
+                                   nodes::TypeStorage &type_storage);
+
+nodes::TypeDefinition build_type_definition(parser::ParseTree::Node parser_node,
+                                            nodes::TypeStorage &type_storage);
+
+nodes::FunctionDefinition build_function_definition(
+    parser::ParseTree::Node parser_node,
+    const std::optional<nodes::Identifier> &previous_defined_type_name,
+    nodes::ExpressionStorage &expression_storage,
+    nodes::TypeStorage &type_storage);
+} // namespace builders

include/builders/type_builders.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "tree_sitter_wrapper.hpp"
+#include "type_nodes.hpp"
+
+namespace builders {
+
+nodes::TypeProxy build_type(parser::ParseTree::Node parse_node,
+                            nodes::TypeStorage &type_storage);
+
+nodes::TupleType build_tuple_type(parser::ParseTree::Node parse_node,
+                                  nodes::TypeStorage &type_storage);
+
+nodes::VariantType build_variant_type(parser::ParseTree::Node parse_node,
+                                      nodes::TypeStorage &type_storage);
+
+} // namespace builders