st/lang
1
0
Fork 0
mirror of https://codeberg.org/ProgramSnail/lang.git synced 2025-12-05 22:48:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

part of statements builders func -> task change

Browse source
This commit is contained in:
dragon 2024-08-16 21:45:45 +03:00
parent cbbf626232
commit 3446d599d7
2 changed files with 94 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

77
lang/builders/include/statement_builders.hpp
View file

@ -1,39 +1,72 @@
#pragma once #pragma once
#include "name_tree.hpp" #include "builders_utils.hpp"
#include "statement_nodes.hpp" #include "statement_nodes.hpp"
#include "tree_sitter_wrapper.hpp"
#include <vector> #include <vector>
// TODO: move to nodes
namespace nodes {
using Statements = std::vector<nodes::Statement>;
} // namespace nodes
namespace builders { namespace builders {
// statements (copies of statements are in name_tree) returned to print / // statements (copies of statements are in name_tree) returned to print /
// translate them in required order // translate them in required order
std::vector<nodes::Statement> template <>
build_source_file(parser::ParseTree::Node parser_node, struct BuilderTask<nodes::Statements>
nodes::ExpressionStorage &expression_storage, : public BuilderTaskBase<nodes::Statements> {
nodes::TypeStorage &type_storage, names::NameTree &name_tree); using BuilderTaskBase<nodes::Statements>::BuilderTaskBase;
nodes::Statements operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
// copy of statement inserted into name_tree // copy of statement inserted into name_tree
nodes::Statement template <>
build_statement(parser::ParseTree::Node parser_node, struct BuilderTask<nodes::Statement>
std::optional<nodes::Identifier> &previous_defined_type_name, : public BuilderTaskBase<nodes::Statement> {
nodes::ExpressionStorage &expression_storage, using BuilderTaskBase<nodes::Statement>::BuilderTaskBase;
nodes::TypeStorage &type_storage, names::NameTree &name_tree);
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, template <>
nodes::ExpressionStorage &expression_storage, struct BuilderTask<nodes::Import> : public BuilderTaskBase<nodes::Import> {
nodes::TypeStorage &type_storage); using BuilderTaskBase<nodes::Import>::BuilderTaskBase;
nodes::TypeDefinition build_type_definition(parser::ParseTree::Node parser_node, nodes::Import operator()(const ParserNode &parser_node,
nodes::TypeStorage &type_storage); const utils::None &args) override;
};
template <>
struct BuilderTask<nodes::Constraint>
: public BuilderTaskBase<nodes::Constraint> {
using BuilderTaskBase<nodes::Constraint>::BuilderTaskBase;
nodes::Constraint operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
template <>
struct BuilderTask<nodes::TypeDefinition>
: public BuilderTaskBase<nodes::TypeDefinition> {
using BuilderTaskBase<nodes::TypeDefinition>::BuilderTaskBase;
nodes::TypeDefinition operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
template <>
struct BuilderTask<nodes::FunctionDefinition>
: public BuilderTaskBase<nodes::FunctionDefinition> {
using BuilderTaskBase<nodes::FunctionDefinition>::BuilderTaskBase;
nodes::FunctionDefinition operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
// const std::optional<nodes::Identifier> &previous_defined_type_name, // TODO
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 } // namespace builders

82
lang/builders/src/statement_builders.cpp
View file

@ -20,20 +20,18 @@
namespace builders { namespace builders {
// statement+ // statement+
std::vector<nodes::Statement> nodes::Statements
build_source_file(parser::ParseTree::Node parser_node, BuilderTask<nodes::Statements>::operator()(const ParserNode &parser_node,
nodes::ExpressionStorage &expression_storage, const utils::None &) {
nodes::TypeStorage &type_storage,
names::NameTree &name_tree) {
std::vector<nodes::Statement> statements; std::vector<nodes::Statement> statements;
std::optional<nodes::Identifier> last_defined_type_name; std::optional<nodes::Identifier> last_defined_type_name;
auto current_node = parser_node.nth_named_child(0); auto current_node = parser_node.nth_named_child(0);
while (!current_node.is_null()) { while (!current_node.is_null()) {
statements.push_back(build_statement(current_node, last_defined_type_name, statements.push_back(
expression_storage, type_storage, Run<nodes::Statement>(current_node /* TODO , last_defined_type_name*/
name_tree)); ));
current_node = current_node.next_named_sibling(); 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 // import | type_definition | function_definition | typeclass_definition
nodes::Statement nodes::Statement
build_statement(parser::ParseTree::Node parser_node, BuilderTask<nodes::Statement>::operator()(const ParserNode &parser_node,
std::optional<nodes::Identifier> &last_defined_type_name, const utils::None &) {
nodes::ExpressionStorage &expression_storage, // std::optional<nodes::Identifier> &last_defined_type_name, // TODO
nodes::TypeStorage &type_storage, names::NameTree &name_tree) {
tokens::Type type = tokens::string_to_type(parser_node.get_type()); tokens::Type type = tokens::string_to_type(parser_node.get_type());
std::optional<std::string> statement_name; std::optional<std::string> statement_name;
@ -53,8 +50,8 @@ build_statement(parser::ParseTree::Node parser_node,
switch (type) { switch (type) {
case tokens::Type::IMPORT: case tokens::Type::IMPORT:
statement = statement = nodes::Statement(build_node(parser_node),
nodes::Statement(build_node(parser_node), build_import(parser_node)); Run<nodes::Import>(parser_node));
statement_name = *statement.value() statement_name = *statement.value()
.get<nodes::Import>() .get<nodes::Import>()
.value() .value()
@ -62,9 +59,8 @@ build_statement(parser::ParseTree::Node parser_node,
->get(); ->get();
break; break;
case tokens::Type::TYPE_DEFINITION: case tokens::Type::TYPE_DEFINITION:
statement = statement = nodes::Statement(build_node(parser_node),
nodes::Statement(build_node(parser_node), Run<nodes::TypeDefinition>(parser_node));
build_type_definition(parser_node, type_storage));
last_defined_type_name = last_defined_type_name =
*statement.value().get<nodes::TypeDefinition>().value()->get_name(); *statement.value().get<nodes::TypeDefinition>().value()->get_name();
statement_name = *statement.value() statement_name = *statement.value()
@ -74,10 +70,11 @@ build_statement(parser::ParseTree::Node parser_node,
->get(); ->get();
break; break;
case tokens::Type::FUNCTION_DEFINITION: case tokens::Type::FUNCTION_DEFINITION:
statement = nodes::Statement( statement =
build_node(parser_node), nodes::Statement(build_node(parser_node),
build_function_definition(parser_node, last_defined_type_name, Run<nodes::FunctionDefinition>(
expression_storage, type_storage)); parser_node /*, TODO last_defined_type_name*/
));
statement_name = *statement.value() statement_name = *statement.value()
.get<nodes::FunctionDefinition>() .get<nodes::FunctionDefinition>()
.value() .value()
@ -103,7 +100,7 @@ build_statement(parser::ParseTree::Node parser_node,
if (statement_name.has_value()) { if (statement_name.has_value()) {
auto statement_copy = statement.value(); auto statement_copy = statement.value();
if (name_tree if (state<Names>()
.insert_combine(statement_name.value(), std::move(statement_copy)) .insert_combine(statement_name.value(), std::move(statement_copy))
.second != nodes::CombineResult::OK) { .second != nodes::CombineResult::OK) {
// TODO: more detailed errors // TODO: more detailed errors
@ -116,7 +113,9 @@ build_statement(parser::ParseTree::Node parser_node,
} }
// ('::' | 'import') simple_name ('=' simple_name)? (':' identifier*)? // ('::' | 'import') simple_name ('=' simple_name)? (':' identifier*)?
nodes::Import build_import(parser::ParseTree::Node parser_node) { nodes::Import
BuilderTask<nodes::Import>::operator()(const ParserNode &parser_node,
const utils::None &) {
auto name_node = parser_node.child_by_field_name("name"); auto name_node = parser_node.child_by_field_name("name");
auto module_node = parser_node.child_by_field_name("module"); auto module_node = parser_node.child_by_field_name("module");
@ -137,12 +136,12 @@ nodes::Import build_import(parser::ParseTree::Node parser_node) {
} }
// '?' expression // '?' expression
nodes::Constraint build_constraint(parser::ParseTree::Node parser_node, nodes::Constraint
nodes::ExpressionStorage &expression_storage, BuilderTask<nodes::Constraint>::operator()(const ParserNode &parser_node,
nodes::TypeStorage &type_storage) { const utils::None &) {
return nodes::Constraint(build_node(parser_node), return nodes::Constraint(
build_expression(parser_node.nth_named_child(0), build_node(parser_node),
expression_storage, type_storage)); Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)));
} }
parser::ParseTree::Node collect_symbol_doc_nodes( 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) // definition_info? annotation_info* '<>'? (simple_type_identifier | typeclass)
// (argument_type* '=' type)? ';' // (argument_type* '=' type)? ';'
nodes::TypeDefinition build_type_definition(parser::ParseTree::Node parser_node, nodes::TypeDefinition
nodes::TypeStorage &type_storage) { BuilderTask<nodes::TypeDefinition>::operator()(const ParserNode &parser_node,
const utils::None &) {
std::optional<parser::ParseTree::Node> description_node; std::optional<parser::ParseTree::Node> description_node;
std::vector<parser::ParseTree::Node> annotation_nodes; std::vector<parser::ParseTree::Node> annotation_nodes;
@ -252,7 +252,7 @@ nodes::TypeDefinition build_type_definition(parser::ParseTree::Node parser_node,
} }
nodes::MaybeTypeProxy type = nodes::MaybeTypeProxy type =
type_node.has_value() ? build_type(type_node.value(), type_storage) type_node.has_value() ? build_type(type_node.value(), state<Types>())
: nodes::MaybeTypeProxy(); : nodes::MaybeTypeProxy();
std::unordered_set<std::string> annotations; std::unordered_set<std::string> annotations;
@ -274,11 +274,9 @@ nodes::TypeDefinition build_type_definition(parser::ParseTree::Node parser_node,
// | '(' operator ')') (annotation? _reference_? argument_name '?'?)* (: // | '(' operator ')') (annotation? _reference_? argument_name '?'?)* (:
// (annotation? _reference_ type)+)? // (annotation? _reference_ type)+)?
// (((block | array) | '=' expression ';') | ';') // (((block | array) | '=' expression ';') | ';')
nodes::FunctionDefinition build_function_definition( nodes::FunctionDefinition BuilderTask<nodes::FunctionDefinition>::operator()(
parser::ParseTree::Node parser_node, const ParserNode &parser_node, const utils::None &) {
const std::optional<nodes::Identifier> &last_defined_type_name, // const std::optional<nodes::Identifier> &last_defined_type_name, // TODO
nodes::ExpressionStorage &expression_storage,
nodes::TypeStorage &type_storage) {
std::optional<parser::ParseTree::Node> description_node; std::optional<parser::ParseTree::Node> description_node;
std::vector<parser::ParseTree::Node> annotation_nodes; std::vector<parser::ParseTree::Node> annotation_nodes;
@ -291,8 +289,7 @@ nodes::FunctionDefinition build_function_definition(
while (!current_node.is_null() && while (!current_node.is_null() &&
tokens::string_to_type(current_node.get_type()) == tokens::string_to_type(current_node.get_type()) ==
tokens::Type::CONSTRAINT) { tokens::Type::CONSTRAINT) {
constraints.push_back( constraints.push_back(Run<nodes::Constraint>(current_node));
build_constraint(current_node, expression_storage, type_storage));
current_node = current_node.next_named_sibling(); current_node = current_node.next_named_sibling();
} }
@ -386,11 +383,11 @@ nodes::FunctionDefinition build_function_definition(
case tokens::Type::SIMPLE_TYPE: case tokens::Type::SIMPLE_TYPE:
if (current_type_id >= arguments.size()) { if (current_type_id >= arguments.size()) {
arguments.push_back(nodes::FunctionDefinition::Argument( arguments.push_back(nodes::FunctionDefinition::Argument(
last_annotation, build_type(current_node, type_storage), last_annotation, build_type(current_node, state<Types>()),
last_before_modifier)); last_before_modifier));
} else { } else {
if (!arguments[current_type_id].add_type( if (!arguments[current_type_id].add_type(
last_annotation, build_type(current_node, type_storage), last_annotation, build_type(current_node, state<Types>()),
last_before_modifier)) { last_before_modifier)) {
error_handling::handle_parsing_error( error_handling::handle_parsing_error(
"It is impossible to use argument modifiers (annotations, " "It is impossible to use argument modifiers (annotations, "
@ -464,8 +461,7 @@ nodes::FunctionDefinition build_function_definition(
build_identifier(name_node), std::move(arguments), build_identifier(name_node), std::move(arguments),
are_annotations_same_to_names, are_annotations_same_to_names,
expression_node.has_value() expression_node.has_value()
? build_expression(expression_node.value(), expression_storage, ? Run<nodes::ExpressionProxy>(expression_node.value())
type_storage)
: std::optional<nodes::ExpressionProxy>()); : std::optional<nodes::ExpressionProxy>());
} }