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

better expr proxy builder task

Browse source
This commit is contained in:
dragon 2024-08-16 21:27:57 +03:00
parent f5856734c6
commit cbbf626232
4 changed files with 217 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

2
lang/builders/include/builders_utils.hpp
View file

@ -13,6 +13,8 @@ using Names = names::NameTree;
using Executor = utils::Executor<Exprs, Types, Names>;
using ParserNode = parser::ParseTree::Node;
using Node = nodes::Node_<nodes::NodePart<utils::Pos>>; // TODO
template <typename N>

47
lang/builders/include/expression_builders.hpp
View file

@ -28,7 +28,7 @@ struct BuilderTask<nodes::ExpressionProxy>
: public BuilderTaskBase<nodes::ExpressionProxy> {
using BuilderTaskBase<nodes::ExpressionProxy>::BuilderTaskBase;
nodes::ExpressionProxy operator()(const parser::ParseTree::Node &parser_node,
nodes::ExpressionProxy operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -37,7 +37,7 @@ struct BuilderTask<nodes::Match::Case>
: public BuilderTaskBase<nodes::Match::Case> {
using BuilderTaskBase<nodes::Match::Case>::BuilderTaskBase;
nodes::Match::Case operator()(const parser::ParseTree::Node &parser_node,
nodes::Match::Case operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -45,7 +45,7 @@ template <>
struct BuilderTask<nodes::Match> : public BuilderTaskBase<nodes::Match> {
using BuilderTaskBase<nodes::Match>::BuilderTaskBase;
nodes::Match operator()(const parser::ParseTree::Node &parser_node,
nodes::Match operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -54,7 +54,7 @@ struct BuilderTask<nodes::Condition>
: public BuilderTaskBase<nodes::Condition> {
using BuilderTaskBase<nodes::Condition>::BuilderTaskBase;
nodes::Condition operator()(const parser::ParseTree::Node &parser_node,
nodes::Condition operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -62,7 +62,7 @@ template <>
struct BuilderTask<nodes::Loop> : public BuilderTaskBase<nodes::Loop> {
using BuilderTaskBase<nodes::Loop>::BuilderTaskBase;
nodes::Loop operator()(const parser::ParseTree::Node &parser_node,
nodes::Loop operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -73,7 +73,7 @@ struct BuilderTask<nodes::NameExpression, utils::CommaTag>
: public BuilderTaskBase<nodes::NameExpression> {
using BuilderTaskBase<nodes::NameExpression>::BuilderTaskBase;
nodes::NameExpression operator()(const parser::ParseTree::Node &parser_node,
nodes::NameExpression operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -82,7 +82,7 @@ struct BuilderTask<nodes::NameExpression, utils::OperatorTag>
: public BuilderTaskBase<nodes::NameExpression> {
using BuilderTaskBase<nodes::NameExpression>::BuilderTaskBase;
nodes::NameExpression operator()(const parser::ParseTree::Node &parser_node,
nodes::NameExpression operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -98,7 +98,7 @@ struct BuilderTask<nodes::Container, T>
// '{' (expression ';')* '}'
// or
// '[[' expression+ ']]'
nodes::Container operator()(const parser::ParseTree::Node &parser_node,
nodes::Container operator()(const ParserNode &parser_node,
const utils::None &) override {
const auto container_type = std::is_same_v<T, utils::BlockTag>
? nodes::Container::BLOCK
@ -124,7 +124,7 @@ template <>
struct BuilderTask<nodes::Return> : public BuilderTaskBase<nodes::Return> {
using BuilderTaskBase<nodes::Return>::BuilderTaskBase;
nodes::Return operator()(const parser::ParseTree::Node &parser_node,
nodes::Return operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -133,7 +133,7 @@ struct BuilderTask<nodes::NameDefinition>
: public BuilderTaskBase<nodes::NameDefinition> {
using BuilderTaskBase<nodes::NameDefinition>::BuilderTaskBase;
nodes::NameDefinition operator()(const parser::ParseTree::Node &parser_node,
nodes::NameDefinition operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -142,7 +142,7 @@ struct BuilderTask<nodes::Access, utils::ArrayAccessTag>
: public BuilderTaskBase<nodes::Access> {
using BuilderTaskBase<nodes::Access>::BuilderTaskBase;
nodes::Access operator()(const parser::ParseTree::Node &parser_node,
nodes::Access operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -151,7 +151,7 @@ struct BuilderTask<nodes::Access, utils::TupleAccessTag>
: public BuilderTaskBase<nodes::Access> {
using BuilderTaskBase<nodes::Access>::BuilderTaskBase;
nodes::Access operator()(const parser::ParseTree::Node &parser_node,
nodes::Access operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -160,7 +160,7 @@ struct BuilderTask<nodes::LoopControl>
: public BuilderTaskBase<nodes::LoopControl> {
using BuilderTaskBase<nodes::LoopControl>::BuilderTaskBase;
nodes::LoopControl operator()(const parser::ParseTree::Node &parser_node,
nodes::LoopControl operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -169,9 +169,8 @@ struct BuilderTask<nodes::ModifierExpression, utils::RefTag>
: public BuilderTaskBase<nodes::ModifierExpression> {
using BuilderTaskBase<nodes::ModifierExpression>::BuilderTaskBase;
nodes::ModifierExpression
operator()(const parser::ParseTree::Node &parser_node,
const utils::None &args) override;
nodes::ModifierExpression operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
template <>
@ -179,9 +178,8 @@ struct BuilderTask<nodes::ModifierExpression, utils::SuffixTag>
: public BuilderTaskBase<nodes::ModifierExpression> {
using BuilderTaskBase<nodes::ModifierExpression>::BuilderTaskBase;
nodes::ModifierExpression
operator()(const parser::ParseTree::Node &parser_node,
const utils::None &args) override;
nodes::ModifierExpression operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
template <typename T>
@ -194,9 +192,8 @@ struct BuilderTask<nodes::ModifierExpression, T>
// _reference_ expression
// or
// expression ('?' | '!')
nodes::ModifierExpression
operator()(const parser::ParseTree::Node &parser_node,
const utils::None &) override {
nodes::ModifierExpression operator()(const ParserNode &parser_node,
const utils::None &) override {
const size_t modifier_pos =
std::is_same_v<T, utils::RefTag> ? 0 : parser_node.child_count() - 1;
@ -214,7 +211,7 @@ struct BuilderTask<nodes::NameExpression, utils::FuncCallTag>
: public BuilderTaskBase<nodes::NameExpression> {
using BuilderTaskBase<nodes::NameExpression>::BuilderTaskBase;
nodes::NameExpression operator()(const parser::ParseTree::Node &parser_node,
nodes::NameExpression operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -223,7 +220,7 @@ struct BuilderTask<nodes::Constructor>
: public BuilderTaskBase<nodes::Constructor> {
using BuilderTaskBase<nodes::Constructor>::BuilderTaskBase;
nodes::Constructor operator()(const parser::ParseTree::Node &parser_node,
nodes::Constructor operator()(const ParserNode &parser_node,
const utils::None &args) override;
};
@ -231,7 +228,7 @@ template <>
struct BuilderTask<nodes::Lambda> : public BuilderTaskBase<nodes::Lambda> {
using BuilderTaskBase<nodes::Lambda>::BuilderTaskBase;
nodes::Lambda operator()(const parser::ParseTree::Node &parser_node,
nodes::Lambda operator()(const ParserNode &parser_node,
const utils::None &args) override;
};

297
lang/builders/src/expression_builders.cpp
View file

@ -10,8 +10,9 @@
namespace builders {
nodes::ExpressionProxy BuilderTask<nodes::ExpressionProxy>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
nodes::ExpressionProxy
BuilderTask<nodes::ExpressionProxy>::operator()(const ParserNode &parser_node,
const utils::None &) {
tokens::Type type = tokens::string_to_type(parser_node.get_type());
auto maybe_parenthesis = parser_node.previous_sibling();
@ -19,150 +20,141 @@ nodes::ExpressionProxy BuilderTask<nodes::ExpressionProxy>::operator()(
(!maybe_parenthesis.is_null() && !maybe_parenthesis.is_named() &&
maybe_parenthesis.get_value() == "(");
std::optional<nodes::Expression::Type> expr;
switch (type) {
// --- flow control
case tokens::Type::MATCH:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), Run<nodes::Match>(parser_node), is_scoped));
expr = Run<nodes::Match>(parser_node);
break;
case tokens::Type::CONDITION:
return state<Exprs>().add_expression(
nodes::Expression(build_node(parser_node),
Run<nodes::Condition>(parser_node), is_scoped));
return state<Exprs>().add_expression({build_node(parser_node),
Run<nodes::Condition>(parser_node),
is_scoped});
expr = Run<nodes::Match>(parser_node);
break;
case tokens::Type::LOOP:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), Run<nodes::Loop>(parser_node), is_scoped));
return state<Exprs>().add_expression(
{build_node(parser_node), Run<nodes::Loop>(parser_node), is_scoped});
expr = Run<nodes::Match>(parser_node);
break;
// --- operators
case tokens::Type::COMMA_EXPRESSION:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node),
Run<nodes::NameExpression, utils::CommaTag>(parser_node), is_scoped));
expr = Run<nodes::NameExpression, utils::CommaTag>(parser_node);
break;
case tokens::Type::OPERATOR_EXPRESSION:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node),
Run<nodes::NameExpression, utils::OperatorTag>(parser_node),
is_scoped));
expr = Run<nodes::NameExpression, utils::OperatorTag>(parser_node);
break;
// --- containers
case tokens::Type::BLOCK:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node),
Run<nodes::Container, utils::BlockTag>(parser_node), is_scoped));
expr = Run<nodes::Container, utils::BlockTag>(parser_node);
break;
case tokens::Type::ARRAY:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node),
Run<nodes::Container, utils::ArrayTag>(parser_node), is_scoped));
expr = Run<nodes::Container, utils::ArrayTag>(parser_node);
break;
// --- modifiers
case tokens::Type::RETURN:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), Run<nodes::Return>(parser_node), is_scoped));
expr = Run<nodes::Return>(parser_node);
break;
case tokens::Type::NAME_DEFINITION:
return state<Exprs>().add_expression(
nodes::Expression(build_node(parser_node),
Run<nodes::NameDefinition>(parser_node), is_scoped));
expr = Run<nodes::NameDefinition>(parser_node);
break;
case tokens::Type::ARRAY_ACCESS:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node),
Run<nodes::Access, utils::ArrayAccessTag>(parser_node), is_scoped));
expr = Run<nodes::Access, utils::ArrayAccessTag>(parser_node);
break;
case tokens::Type::TUPLE_ACCESS:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node),
Run<nodes::Access, utils::TupleAccessTag>(parser_node), is_scoped));
expr = Run<nodes::Access, utils::TupleAccessTag>(parser_node);
break;
case tokens::Type::LOOP_CONTROL:
return state<Exprs>().add_expression(
nodes::Expression(build_node(parser_node),
Run<nodes::LoopControl>(parser_node), is_scoped));
expr = Run<nodes::LoopControl>(parser_node);
break;
case tokens::Type::REFERENCE_EXPRESSION:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node),
Run<nodes::ModifierExpression, utils::RefTag>(parser_node), is_scoped));
expr = Run<nodes::ModifierExpression, utils::RefTag>(parser_node);
break;
case tokens::Type::SUFFIX_EXPRESSION:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node),
Run<nodes::ModifierExpression, utils::SuffixTag>(parser_node),
is_scoped));
expr = Run<nodes::ModifierExpression, utils::SuffixTag>(parser_node);
break;
// --- other
case tokens::Type::NAME_EXPRESSION:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node),
Run<nodes::NameExpression, utils::FuncCallTag>(parser_node),
is_scoped));
expr = Run<nodes::NameExpression, utils::FuncCallTag>(parser_node);
break;
case tokens::Type::ARGUMENT_NAME_IDENTIFIER:
case tokens::Type::SIMPLE_NAME_IDENTIFIER:
case tokens::Type::PLACEHOLDER:
return state<Exprs>().add_expression(
nodes::Expression(build_node(parser_node),
nodes::NameExpression(build_node(parser_node),
build_identifier(parser_node)),
is_scoped));
expr = nodes::NameExpression(build_node(parser_node),
build_identifier(parser_node));
break;
case tokens::Type::CONSTRUCTOR:
return state<Exprs>().add_expression(
nodes::Expression(build_node(parser_node),
Run<nodes::Constructor>(parser_node), is_scoped));
expr = Run<nodes::Constructor>(parser_node);
break;
case tokens::Type::LAMBDA:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), Run<nodes::Lambda>(parser_node), is_scoped));
expr = Run<nodes::Lambda>(parser_node);
break;
// --- literals
case tokens::Type::FLOAT_LITERAL:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_float_literal(parser_node), is_scoped));
expr = build_float_literal(parser_node);
break;
case tokens::Type::DOUBLE_LITERAL:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_double_literal(parser_node), is_scoped));
expr = build_double_literal(parser_node);
break;
case tokens::Type::INT_LITERAL:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_int_literal(parser_node), is_scoped));
expr = build_int_literal(parser_node);
break;
case tokens::Type::LONG_LITERAL:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_long_literal(parser_node), is_scoped));
expr = build_long_literal(parser_node);
break;
case tokens::Type::INDEX_LITERAL:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_index_literal(parser_node), is_scoped));
expr = build_index_literal(parser_node);
break;
case tokens::Type::STRING_LITERAL:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_string_literal(parser_node), is_scoped));
expr = build_string_literal(parser_node);
break;
case tokens::Type::UNICODE_STRING_LITERAL:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_unicode_string_literal(parser_node),
is_scoped));
expr = build_unicode_string_literal(parser_node);
break;
case tokens::Type::CHAR_LITERAL:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_char_literal(parser_node), is_scoped));
expr = build_char_literal(parser_node);
break;
case tokens::Type::UNICODE_LITERAL:
return state<Exprs>().add_expression(
nodes::Expression(build_node(parser_node),
build_unicode_literal(parser_node), is_scoped));
expr = build_unicode_literal(parser_node);
break;
case tokens::Type::BOOL_LITERAL:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_bool_literal(parser_node), is_scoped));
expr = build_bool_literal(parser_node);
break;
case tokens::Type::UNIT_LITERAL:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_unit_literal(parser_node), is_scoped));
expr = build_unit_literal(parser_node);
break;
case tokens::Type::NULL_LITERAL:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_null_literal(parser_node), is_scoped));
expr = build_null_literal(parser_node);
break;
case tokens::Type::EXTRA:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_extra(parser_node), is_scoped));
expr = build_extra(parser_node);
break;
case tokens::Type::EMPTY_LINES:
return state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node), build_empty_lines(parser_node), is_scoped));
expr = build_empty_lines(parser_node);
break;
default:
error_handling::handle_parsing_error("Unexprected expression node type",
parser_node);
utils::Assert(true,
std::format("Unexpected expression node type {}",
static_cast<int>(type))); // TODO: magic_enum
// FIXME: change to fatal error ?
}
error_handling::handle_general_error("Unreachable");
exit(1); // unreachable
utils::Assert(expr.has_value(), "Expression should have value");
return state<Exprs>().add_expression(
{build_node(parser_node), expr.value(), is_scoped});
}
// --- flow control
// (':=' | '=:') expression (('??' | 'if') expression)? (_do_ expression)?
nodes::Match::Case BuilderTask<nodes::Match::Case>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
nodes::Match::Case
BuilderTask<nodes::Match::Case>::operator()(const ParserNode &parser_node,
const utils::None &) {
std::string case_type = parser_node.nth_child(0).get_value();
std::optional<parser::ParseTree::Node> condition_node;
std::optional<parser::ParseTree::Node> expression_node;
std::optional<ParserNode> condition_node;
std::optional<ParserNode> expression_node;
auto current_node = parser_node.nth_named_child(1);
@ -192,8 +184,9 @@ nodes::Match::Case BuilderTask<nodes::Match::Case>::operator()(
}
// expression case+
nodes::Match BuilderTask<nodes::Match>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
nodes::Match
BuilderTask<nodes::Match>::operator()(const ParserNode &parser_node,
const utils::None &) {
std::vector<nodes::Match::Case> cases;
auto current_node = parser_node.nth_named_child(1);
@ -210,8 +203,9 @@ nodes::Match BuilderTask<nodes::Match>::operator()(
// ('??' | 'if') expression _do_ expression (('!!' | 'elif') expression _do_
// expression)* (('!!=>', 'else') expression)?
nodes::Condition BuilderTask<nodes::Condition>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
nodes::Condition
BuilderTask<nodes::Condition>::operator()(const ParserNode &parser_node,
const utils::None &) {
size_t named_child_count = parser_node.named_child_count();
std::vector<std::pair<nodes::ExpressionProxy, nodes::ExpressionProxy>> cases;
@ -238,32 +232,48 @@ nodes::Condition BuilderTask<nodes::Condition>::operator()(
}
// ('@' | 'for') (expression | expression ':' expression)? _do_ expression
nodes::Loop
BuilderTask<nodes::Loop>::operator()(const parser::ParseTree::Node &parser_node,
const utils::None &) {
nodes::Loop BuilderTask<nodes::Loop>::operator()(const ParserNode &parser_node,
const utils::None &) {
size_t named_child_count = parser_node.named_child_count();
if (named_child_count == 1) { // body
return nodes::Loop(
build_node(parser_node),
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)));
} else if (named_child_count == 2) { // condition, body
} else if (named_child_count == 2) { // condition,
// body
return nodes::Loop(
build_node(parser_node),
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)),
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(1)));
} else if (named_child_count == 3) { // variable, interval, body
} else if (named_child_count == 3) { // variable,
// interval,
// body
return nodes::Loop(
build_node(parser_node),
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)),
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(1)),
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(2)));
} else {
error_handling::handle_parsing_error(
"Unexprected named expression amount in loop", parser_node);
error_handling::handle_parsing_error("Unex"
"prec"
"ted "
"name"
"d "
"expr"
"essi"
"on "
"amou"
"nt "
"in "
"loo"
"p",
parser_node);
}
error_handling::handle_general_error("Unreachable");
error_handling::handle_general_error("Unreac"
"habl"
"e");
exit(1); // unreachable
}
@ -272,7 +282,7 @@ BuilderTask<nodes::Loop>::operator()(const parser::ParseTree::Node &parser_node,
// expression ',' expression
nodes::NameExpression
BuilderTask<nodes::NameExpression, utils::CommaTag>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
const ParserNode &parser_node, const utils::None &) {
std::vector<std::pair<std::optional<std::string>, nodes::ExpressionProxy>>
arguments;
@ -293,8 +303,10 @@ BuilderTask<nodes::NameExpression, utils::CommaTag>::operator()(
// expression operator expression
nodes::NameExpression
BuilderTask<nodes::NameExpression, utils::OperatorTag>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
auto name_node = parser_node.child_by_field_name("name");
const ParserNode &parser_node, const utils::None &) {
auto name_node = parser_node.child_by_field_name("na"
"m"
"e");
std::vector<std::pair<std::optional<std::string>, nodes::ExpressionProxy>>
arguments;
@ -317,19 +329,25 @@ BuilderTask<nodes::NameExpression, utils::OperatorTag>::operator()(
// --- modifiers
// ('return' | 'bring') expression
nodes::Return BuilderTask<nodes::Return>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
nodes::Return
BuilderTask<nodes::Return>::operator()(const ParserNode &parser_node,
const utils::None &) {
std::string modifier = parser_node.nth_child(0).get_value();
return nodes::Return(
build_node(parser_node),
modifier == "return" ? nodes::Return::RETURN : nodes::Return::BRING,
modifier == "re"
"tu"
"rn"
? nodes::Return::RETURN
: nodes::Return::BRING,
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)));
}
// _var_let_ (simple_name_identifier | placeholder)
nodes::NameDefinition BuilderTask<nodes::NameDefinition>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
nodes::NameDefinition
BuilderTask<nodes::NameDefinition>::operator()(const ParserNode &parser_node,
const utils::None &) {
std::string modifier = parser_node.nth_child(0).get_value();
auto name_node = parser_node.nth_named_child(0);
@ -343,7 +361,7 @@ nodes::NameDefinition BuilderTask<nodes::NameDefinition>::operator()(
// expression '[' expression ']'
nodes::Access BuilderTask<nodes::Access, utils::ArrayAccessTag>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
const ParserNode &parser_node, const utils::None &) {
return nodes::Access(
build_node(parser_node), nodes::Access::ARRAY,
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)),
@ -352,20 +370,23 @@ nodes::Access BuilderTask<nodes::Access, utils::ArrayAccessTag>::operator()(
// expression '.' number_literal
nodes::Access BuilderTask<nodes::Access, utils::TupleAccessTag>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
const ParserNode &parser_node, const utils::None &) {
return nodes::Access(
build_node(parser_node), nodes::Access::TUPLE,
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)),
state<Exprs>().add_expression(nodes::Expression(
build_node(parser_node.nth_named_child(1)),
build_index_literal(parser_node.nth_named_child(1)), false)));
state<Exprs>().add_expression(
{build_node(parser_node.nth_named_child(1)),
build_index_literal(parser_node.nth_named_child(1)), false}));
}
// 'break' | 'continue'
nodes::LoopControl BuilderTask<nodes::LoopControl>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
nodes::LoopControl
BuilderTask<nodes::LoopControl>::operator()(const ParserNode &parser_node,
const utils::None &) {
return nodes::LoopControl(build_node(parser_node),
parser_node.get_value() == "break"
parser_node.get_value() == "br"
"ea"
"k"
? nodes::LoopControl::BREAK
: nodes::LoopControl::CONTINUE);
}
@ -375,9 +396,8 @@ nodes::LoopControl BuilderTask<nodes::LoopControl>::operator()(
// --- other
void build_arguments_until_end(
parser::ParseTree::Node first_parse_node, Executor &executor,
ParserNode first_parse_node, Executor &executor,
std::vector<nodes::AnnotatedArgument> &arguments) {
auto current_node = first_parse_node;
std::optional<std::string> last_annotation;
@ -399,16 +419,18 @@ void build_arguments_until_end(
// ')') (annotation? expression)*
nodes::NameExpression
BuilderTask<nodes::NameExpression, utils::FuncCallTag>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
const ParserNode &parser_node, const utils::None &) {
std::vector<nodes::AnnotatedArgument> arguments;
std::optional<nodes::Type> prefix;
bool is_point_call = false;
auto name_node = parser_node.child_by_field_name("name");
auto name_node = parser_node.child_by_field_name("na"
"m"
"e");
std::optional<parser::ParseTree::Node> prefix_node;
std::optional<ParserNode> prefix_node;
auto current_node = name_node.previous_named_sibling();
if (!current_node.is_null()) {
@ -442,13 +464,17 @@ BuilderTask<nodes::NameExpression, utils::FuncCallTag>::operator()(
}
// type (annotation? expression)*
nodes::Constructor BuilderTask<nodes::Constructor>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
nodes::Constructor
BuilderTask<nodes::Constructor>::operator()(const ParserNode &parser_node,
const utils::None &) {
std::vector<nodes::AnnotatedArgument> arguments;
build_arguments_until_end(
parser_node.child_by_field_name("type").next_named_sibling(), executor,
arguments);
build_arguments_until_end(parser_node
.child_by_field_name("ty"
"p"
"e")
.next_named_sibling(),
executor, arguments);
return nodes::Constructor(
build_node(parser_node),
@ -457,8 +483,9 @@ nodes::Constructor BuilderTask<nodes::Constructor>::operator()(
}
// '\\' argument_name* _do_ expression
nodes::Lambda BuilderTask<nodes::Lambda>::operator()(
const parser::ParseTree::Node &parser_node, const utils::None &) {
nodes::Lambda
BuilderTask<nodes::Lambda>::operator()(const ParserNode &parser_node,
const utils::None &) {
std::vector<nodes::Identifier> arguments;
auto current_node =

60
lang/nodes/include/expression_nodes.hpp
View file

@ -529,33 +529,7 @@ private:
class Expression : public Node {
public:
template <typename T>
Expression(Node node, T &&expression, bool is_scoped)
: Node(node), expression_(std::forward<T>(expression)),
is_scoped_(is_scoped) {}
template <typename T> std::optional<T *> get() {
if (std::holds_alternative<T>(expression_)) {
return &std::get<T>(expression_);
}
return std::nullopt;
}
template <typename T> std::optional<const T *> get() const {
if (std::holds_alternative<T>(expression_)) {
return &std::get<T>(expression_);
}
return std::nullopt;
}
auto get_any() { return &expression_; }
auto get_any() const { return &expression_; }
bool is_scoped() const { return is_scoped_; }
private:
std::variant<
using Type = std::variant<
// --- flow control
Match, Condition, Loop,
@ -585,8 +559,36 @@ private:
Extra,
// --- empty lines
EmptyLines>
expression_;
EmptyLines>;
public:
template <typename T>
Expression(Node node, T &&expression, bool is_scoped)
: Node(node), expression_(std::forward<T>(expression)),
is_scoped_(is_scoped) {}
template <typename T> std::optional<T *> get() {
if (std::holds_alternative<T>(expression_)) {
return &std::get<T>(expression_);
}
return std::nullopt;
}
template <typename T> std::optional<const T *> get() const {
if (std::holds_alternative<T>(expression_)) {
return &std::get<T>(expression_);
}
return std::nullopt;
}
auto get_any() { return &expression_; }
auto get_any() const { return &expression_; }
bool is_scoped() const { return is_scoped_; }
private:
Type expression_;
bool is_scoped_ = false;
};