mirror of
https://codeberg.org/ProgramSnail/lang.git
synced 2025-12-05 22:48:43 +00:00
type builders
This commit is contained in:
ProgramSnail
parent
535d8d26c3
commit
0e6d4bd67f
5 changed files with 249 additions and 139 deletions
2
deps/tree-sitter-lang
vendored
2
deps/tree-sitter-lang
vendored
|
|
@ -1 +1 @@
|
|||
Subproject commit 39f31b901dd3f77f33ad7d047ac78d2b94d7ca1d
|
||||
Subproject commit df305457c82a7a9d6e9791ae12a75c7cd16fe663
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -5,11 +5,8 @@
|
|||
|
||||
namespace builders {
|
||||
|
||||
// nodes::Type build_type(parser::ParseTree::Node parse_node,
|
||||
// nodes::TypeStorage &type_storage);
|
||||
|
||||
nodes::TypeProxy build_type_proxy(parser::ParseTree::Node parse_node,
|
||||
nodes::TypeStorage &type_storage);
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -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(
|
||||
nodes::Expression(build_match(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_match(parse_node, expression_storage, type_storage)));
|
||||
case tokens::Type::CONDITION:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_condition(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_condition(parse_node, expression_storage, type_storage)));
|
||||
case tokens::Type::LOOP:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_loop(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
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(
|
||||
build_operator_expression(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_operator_expression(
|
||||
parse_node, expression_storage, type_storage)));
|
||||
// --- containers
|
||||
case tokens::Type::BLOCK:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_block(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_block(parse_node, expression_storage, type_storage)));
|
||||
case tokens::Type::ARRAY:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_array(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_array(parse_node, expression_storage, type_storage)));
|
||||
// --- modifiers
|
||||
case tokens::Type::RETURN:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_return(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
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(
|
||||
nodes::Expression(build_array_access(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_array_access(parse_node, expression_storage, type_storage)));
|
||||
case tokens::Type::TUPLE_ACCESS:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_tuple_access(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
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(
|
||||
build_reference_expression(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(
|
||||
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(
|
||||
nodes::Expression(build_constructor(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_constructor(parse_node, expression_storage, type_storage)));
|
||||
case tokens::Type::LAMBDA:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_lambda(parse_node, expression_storage)));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
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(
|
||||
build_node(parse_node),
|
||||
build_expression(parse_node.nth_named_child(0), expression_storage),
|
||||
std::move(cases));
|
||||
return nodes::Match(build_node(parse_node),
|
||||
build_expression(parse_node.nth_named_child(0),
|
||||
expression_storage, type_storage),
|
||||
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),
|
||||
build_expression(next_node, expression_storage)});
|
||||
cases.push_back(
|
||||
{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(
|
||||
build_node(parse_node),
|
||||
build_expression(parse_node.nth_named_child(0), expression_storage));
|
||||
return nodes::Loop(build_node(parse_node),
|
||||
build_expression(parse_node.nth_named_child(0),
|
||||
expression_storage, type_storage));
|
||||
} else if (named_child_count == 2) { // condition, body
|
||||
return nodes::Loop(
|
||||
build_node(parse_node),
|
||||
build_expression(parse_node.nth_named_child(0), expression_storage),
|
||||
build_expression(parse_node.nth_named_child(1), expression_storage));
|
||||
return nodes::Loop(build_node(parse_node),
|
||||
build_expression(parse_node.nth_named_child(0),
|
||||
expression_storage, type_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(
|
||||
build_node(parse_node),
|
||||
build_expression(parse_node.nth_named_child(0), expression_storage),
|
||||
build_expression(parse_node.nth_named_child(1), expression_storage),
|
||||
build_expression(parse_node.nth_named_child(2), expression_storage));
|
||||
return nodes::Loop(build_node(parse_node),
|
||||
build_expression(parse_node.nth_named_child(0),
|
||||
expression_storage, type_storage),
|
||||
build_expression(parse_node.nth_named_child(1),
|
||||
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(
|
||||
std::nullopt,
|
||||
build_expression(parse_node.nth_named_child(0), expression_storage));
|
||||
arguments.emplace_back(std::nullopt,
|
||||
build_expression(parse_node.nth_named_child(0),
|
||||
expression_storage, type_storage));
|
||||
|
||||
arguments.emplace_back(
|
||||
std::nullopt,
|
||||
build_expression(parse_node.nth_named_child(1), expression_storage));
|
||||
arguments.emplace_back(std::nullopt,
|
||||
build_expression(parse_node.nth_named_child(1),
|
||||
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(
|
||||
std::nullopt,
|
||||
build_expression(name_node.previous_named_sibling(), expression_storage));
|
||||
arguments.emplace_back(std::nullopt,
|
||||
build_expression(name_node.previous_named_sibling(),
|
||||
expression_storage, type_storage));
|
||||
|
||||
arguments.emplace_back(
|
||||
std::nullopt,
|
||||
build_expression(name_node.next_named_sibling(), expression_storage));
|
||||
arguments.emplace_back(std::nullopt,
|
||||
build_expression(name_node.next_named_sibling(),
|
||||
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) {
|
||||
return build_container(parse_node, expression_storage,
|
||||
nodes::ExpressionStorage &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) {
|
||||
return build_container(parse_node, expression_storage,
|
||||
nodes::ExpressionStorage &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(
|
||||
build_node(parse_node),
|
||||
modifier == "return" ? nodes::Return::RETURN : nodes::Return::BRING,
|
||||
build_expression(parse_node.nth_named_child(0), expression_storage));
|
||||
return nodes::Return(build_node(parse_node),
|
||||
modifier == "return" ? nodes::Return::RETURN
|
||||
: nodes::Return::BRING,
|
||||
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) {
|
||||
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(1), expression_storage));
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
return nodes::Access(build_node(parse_node), nodes::Access::ARRAY,
|
||||
build_expression(parse_node.nth_named_child(0),
|
||||
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) {
|
||||
return build_modifier_expression(parse_node, expression_storage, 0);
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
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) {
|
||||
return build_modifier_expression(parse_node, expression_storage,
|
||||
nodes::ExpressionStorage &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()) {
|
||||
if (tokens::string_to_type(type_node.get_type()) == tokens::Type::TYPE) {
|
||||
prefix = build_type(type_node);
|
||||
auto current_node = name_node.previous_named_sibling();
|
||||
if (!current_node.is_null()) {
|
||||
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,
|
||||
build_expression(type_node, expression_storage));
|
||||
arguments.emplace_back(
|
||||
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);
|
||||
} // IN PROGRESS
|
||||
std::move(arguments),
|
||||
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),
|
||||
build_type(parse_node.child_by_field_name("type")),
|
||||
std::move(arguments));
|
||||
return nodes::Constructor(
|
||||
build_node(parse_node),
|
||||
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),
|
||||
build_expression(current_node, expression_storage));
|
||||
return nodes::Lambda(
|
||||
build_node(parse_node), std::move(arguments),
|
||||
build_expression(current_node, expression_storage, type_storage));
|
||||
}
|
||||
|
||||
} // namespace builders
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
// nodes::TypeStorage &type_storage);
|
||||
// '^'? type_identifer '?'? ('[' type+ ']')?
|
||||
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,
|
||||
nodes::TypeStorage &type_storage);
|
||||
auto name_node = parse_node.child_by_field_name("name");
|
||||
|
||||
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
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue