From 3446d599d79bbd1b330efa3157e76df23d3b9f87 Mon Sep 17 00:00:00 2001 From: dragon Date: Fri, 16 Aug 2024 21:45:45 +0300 Subject: [PATCH] part of statements builders func -> task change --- lang/builders/include/statement_builders.hpp | 77 ++++++++++++------ lang/builders/src/statement_builders.cpp | 82 ++++++++++---------- 2 files changed, 94 insertions(+), 65 deletions(-) diff --git a/lang/builders/include/statement_builders.hpp b/lang/builders/include/statement_builders.hpp index 61fd0b2..caa8f19 100644 --- a/lang/builders/include/statement_builders.hpp +++ b/lang/builders/include/statement_builders.hpp @@ -1,39 +1,72 @@ #pragma once -#include "name_tree.hpp" +#include "builders_utils.hpp" #include "statement_nodes.hpp" -#include "tree_sitter_wrapper.hpp" #include +// TODO: move to nodes +namespace nodes { +using Statements = std::vector; +} // namespace nodes + namespace builders { // statements (copies of statements are in name_tree) returned to print / // translate them in required order -std::vector -build_source_file(parser::ParseTree::Node parser_node, - nodes::ExpressionStorage &expression_storage, - nodes::TypeStorage &type_storage, names::NameTree &name_tree); +template <> +struct BuilderTask + : public BuilderTaskBase { + using BuilderTaskBase::BuilderTaskBase; + + nodes::Statements operator()(const ParserNode &parser_node, + const utils::None &args) override; +}; // copy of statement inserted into name_tree -nodes::Statement -build_statement(parser::ParseTree::Node parser_node, - std::optional &previous_defined_type_name, - nodes::ExpressionStorage &expression_storage, - nodes::TypeStorage &type_storage, names::NameTree &name_tree); +template <> +struct BuilderTask + : public BuilderTaskBase { + using BuilderTaskBase::BuilderTaskBase; -nodes::Import build_import(parser::ParseTree::Node parser_node); + nodes::Statement operator()(const ParserNode &parser_node, + const utils::None &args) override; +}; -nodes::Constraint build_constraint(parser::ParseTree::Node parser_node, - nodes::ExpressionStorage &expression_storage, - nodes::TypeStorage &type_storage); +template <> +struct BuilderTask : public BuilderTaskBase { + using BuilderTaskBase::BuilderTaskBase; -nodes::TypeDefinition build_type_definition(parser::ParseTree::Node parser_node, - nodes::TypeStorage &type_storage); + nodes::Import operator()(const ParserNode &parser_node, + const utils::None &args) override; +}; + +template <> +struct BuilderTask + : public BuilderTaskBase { + using BuilderTaskBase::BuilderTaskBase; + + nodes::Constraint operator()(const ParserNode &parser_node, + const utils::None &args) override; +}; + +template <> +struct BuilderTask + : public BuilderTaskBase { + using BuilderTaskBase::BuilderTaskBase; + + nodes::TypeDefinition operator()(const ParserNode &parser_node, + const utils::None &args) override; +}; + +template <> +struct BuilderTask + : public BuilderTaskBase { + using BuilderTaskBase::BuilderTaskBase; + + nodes::FunctionDefinition operator()(const ParserNode &parser_node, + const utils::None &args) override; +}; +// const std::optional &previous_defined_type_name, // TODO -nodes::FunctionDefinition build_function_definition( - parser::ParseTree::Node parser_node, - const std::optional &previous_defined_type_name, - nodes::ExpressionStorage &expression_storage, - nodes::TypeStorage &type_storage); } // namespace builders diff --git a/lang/builders/src/statement_builders.cpp b/lang/builders/src/statement_builders.cpp index 9d7ac6c..28545e7 100644 --- a/lang/builders/src/statement_builders.cpp +++ b/lang/builders/src/statement_builders.cpp @@ -20,20 +20,18 @@ namespace builders { // statement+ -std::vector -build_source_file(parser::ParseTree::Node parser_node, - nodes::ExpressionStorage &expression_storage, - nodes::TypeStorage &type_storage, - names::NameTree &name_tree) { +nodes::Statements +BuilderTask::operator()(const ParserNode &parser_node, + const utils::None &) { std::vector statements; std::optional last_defined_type_name; auto current_node = parser_node.nth_named_child(0); while (!current_node.is_null()) { - statements.push_back(build_statement(current_node, last_defined_type_name, - expression_storage, type_storage, - name_tree)); + statements.push_back( + Run(current_node /* TODO , last_defined_type_name*/ + )); current_node = current_node.next_named_sibling(); } @@ -42,10 +40,9 @@ build_source_file(parser::ParseTree::Node parser_node, // import | type_definition | function_definition | typeclass_definition nodes::Statement -build_statement(parser::ParseTree::Node parser_node, - std::optional &last_defined_type_name, - nodes::ExpressionStorage &expression_storage, - nodes::TypeStorage &type_storage, names::NameTree &name_tree) { +BuilderTask::operator()(const ParserNode &parser_node, + const utils::None &) { + // std::optional &last_defined_type_name, // TODO tokens::Type type = tokens::string_to_type(parser_node.get_type()); std::optional statement_name; @@ -53,8 +50,8 @@ build_statement(parser::ParseTree::Node parser_node, switch (type) { case tokens::Type::IMPORT: - statement = - nodes::Statement(build_node(parser_node), build_import(parser_node)); + statement = nodes::Statement(build_node(parser_node), + Run(parser_node)); statement_name = *statement.value() .get() .value() @@ -62,9 +59,8 @@ build_statement(parser::ParseTree::Node parser_node, ->get(); break; case tokens::Type::TYPE_DEFINITION: - statement = - nodes::Statement(build_node(parser_node), - build_type_definition(parser_node, type_storage)); + statement = nodes::Statement(build_node(parser_node), + Run(parser_node)); last_defined_type_name = *statement.value().get().value()->get_name(); statement_name = *statement.value() @@ -74,10 +70,11 @@ build_statement(parser::ParseTree::Node parser_node, ->get(); break; case tokens::Type::FUNCTION_DEFINITION: - statement = nodes::Statement( - build_node(parser_node), - build_function_definition(parser_node, last_defined_type_name, - expression_storage, type_storage)); + statement = + nodes::Statement(build_node(parser_node), + Run( + parser_node /*, TODO last_defined_type_name*/ + )); statement_name = *statement.value() .get() .value() @@ -103,7 +100,7 @@ build_statement(parser::ParseTree::Node parser_node, if (statement_name.has_value()) { auto statement_copy = statement.value(); - if (name_tree + if (state() .insert_combine(statement_name.value(), std::move(statement_copy)) .second != nodes::CombineResult::OK) { // TODO: more detailed errors @@ -116,7 +113,9 @@ build_statement(parser::ParseTree::Node parser_node, } // ('::' | 'import') simple_name ('=' simple_name)? (':' identifier*)? -nodes::Import build_import(parser::ParseTree::Node parser_node) { +nodes::Import +BuilderTask::operator()(const ParserNode &parser_node, + const utils::None &) { auto name_node = parser_node.child_by_field_name("name"); auto module_node = parser_node.child_by_field_name("module"); @@ -137,12 +136,12 @@ nodes::Import build_import(parser::ParseTree::Node parser_node) { } // '?' expression -nodes::Constraint build_constraint(parser::ParseTree::Node parser_node, - nodes::ExpressionStorage &expression_storage, - nodes::TypeStorage &type_storage) { - return nodes::Constraint(build_node(parser_node), - build_expression(parser_node.nth_named_child(0), - expression_storage, type_storage)); +nodes::Constraint +BuilderTask::operator()(const ParserNode &parser_node, + const utils::None &) { + return nodes::Constraint( + build_node(parser_node), + Run(parser_node.nth_named_child(0))); } parser::ParseTree::Node collect_symbol_doc_nodes( @@ -176,8 +175,9 @@ parser::ParseTree::Node collect_symbol_doc_nodes( // definition_info? annotation_info* '<>'? (simple_type_identifier | typeclass) // (argument_type* '=' type)? ';' -nodes::TypeDefinition build_type_definition(parser::ParseTree::Node parser_node, - nodes::TypeStorage &type_storage) { +nodes::TypeDefinition +BuilderTask::operator()(const ParserNode &parser_node, + const utils::None &) { std::optional description_node; std::vector annotation_nodes; @@ -252,7 +252,7 @@ nodes::TypeDefinition build_type_definition(parser::ParseTree::Node parser_node, } nodes::MaybeTypeProxy type = - type_node.has_value() ? build_type(type_node.value(), type_storage) + type_node.has_value() ? build_type(type_node.value(), state()) : nodes::MaybeTypeProxy(); std::unordered_set annotations; @@ -274,11 +274,9 @@ nodes::TypeDefinition build_type_definition(parser::ParseTree::Node parser_node, // | '(' operator ')') (annotation? _reference_? argument_name '?'?)* (: // (annotation? _reference_ type)+)? // (((block | array) | '=' expression ';') | ';') -nodes::FunctionDefinition build_function_definition( - parser::ParseTree::Node parser_node, - const std::optional &last_defined_type_name, - nodes::ExpressionStorage &expression_storage, - nodes::TypeStorage &type_storage) { +nodes::FunctionDefinition BuilderTask::operator()( + const ParserNode &parser_node, const utils::None &) { + // const std::optional &last_defined_type_name, // TODO std::optional description_node; std::vector annotation_nodes; @@ -291,8 +289,7 @@ nodes::FunctionDefinition build_function_definition( while (!current_node.is_null() && tokens::string_to_type(current_node.get_type()) == tokens::Type::CONSTRAINT) { - constraints.push_back( - build_constraint(current_node, expression_storage, type_storage)); + constraints.push_back(Run(current_node)); current_node = current_node.next_named_sibling(); } @@ -386,11 +383,11 @@ nodes::FunctionDefinition build_function_definition( case tokens::Type::SIMPLE_TYPE: if (current_type_id >= arguments.size()) { arguments.push_back(nodes::FunctionDefinition::Argument( - last_annotation, build_type(current_node, type_storage), + last_annotation, build_type(current_node, state()), last_before_modifier)); } else { if (!arguments[current_type_id].add_type( - last_annotation, build_type(current_node, type_storage), + last_annotation, build_type(current_node, state()), last_before_modifier)) { error_handling::handle_parsing_error( "It is impossible to use argument modifiers (annotations, " @@ -464,8 +461,7 @@ nodes::FunctionDefinition build_function_definition( build_identifier(name_node), std::move(arguments), are_annotations_same_to_names, expression_node.has_value() - ? build_expression(expression_node.value(), expression_storage, - type_storage) + ? Run(expression_node.value()) : std::optional()); }