mirror of
https://codeberg.org/ProgramSnail/lang.git
synced 2025-12-05 22:48:43 +00:00
expression builders: func -> task
This commit is contained in:
dragon
parent
49d9a95fd9
commit
f5856734c6
4 changed files with 364 additions and 343 deletions
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
namespace builders {
|
||||
|
||||
using Code = parser::ParseTree;
|
||||
// using Code = parser::ParseTree;
|
||||
using Exprs = nodes::ExpressionStorage;
|
||||
using Types = nodes::TypeStorage;
|
||||
using Names = names::NameTree;
|
||||
|
|
@ -18,29 +18,19 @@ using Node = nodes::Node_<nodes::NodePart<utils::Pos>>; // TODO
|
|||
template <typename N>
|
||||
using Task = utils::Task<Executor, N, utils::None, parser::ParseTree::Node>;
|
||||
|
||||
template <typename N> struct BuilderTask {
|
||||
template <typename N, typename Tag = utils::None> struct BuilderTask {
|
||||
static_assert(false);
|
||||
};
|
||||
|
||||
template <typename N> struct BuilderTaskBase : public Task<N> {
|
||||
using Task<N>::Task;
|
||||
|
||||
template <typename OtherN>
|
||||
template <typename OtherN, typename OtherTag = utils::None>
|
||||
OtherN Run(const parser::ParseTree::Node &node,
|
||||
const utils::None &args = {}) {
|
||||
BuilderTask<OtherN> task(this->executor);
|
||||
BuilderTask<OtherN, OtherTag> task(this->executor);
|
||||
return task(node, args);
|
||||
}
|
||||
};
|
||||
|
||||
// TODO
|
||||
// template <>
|
||||
// struct BuilderTask<nodes::ExpressionProxy>
|
||||
// : public BuilderTaskBase<nodes::ExpressionProxy> {
|
||||
// using BuilderTaskBase<nodes::ExpressionProxy>::BuilderTaskBase;
|
||||
|
||||
// nodes::ExpressionProxy operator()(const parser::ParseTree::Node &expr,
|
||||
// const utils::None &args) override;
|
||||
// };
|
||||
|
||||
} // namespace builders
|
||||
|
|
|
|||
|
|
@ -1,94 +1,238 @@
|
|||
#pragma once
|
||||
|
||||
#include "basic_builders.hpp"
|
||||
#include "builders_utils.hpp"
|
||||
#include "expression_nodes.hpp"
|
||||
#include "tree_sitter_wrapper.hpp"
|
||||
|
||||
namespace utils {
|
||||
|
||||
struct CommaTag {};
|
||||
struct OperatorTag {};
|
||||
struct BlockTag {};
|
||||
struct ArrayTag {};
|
||||
struct ArrayAccessTag {};
|
||||
struct TupleAccessTag {};
|
||||
struct RefTag {};
|
||||
struct SuffixTag {};
|
||||
struct FuncCallTag {};
|
||||
|
||||
} // namespace utils
|
||||
|
||||
namespace builders {
|
||||
|
||||
// --- flow control
|
||||
|
||||
nodes::ExpressionProxy
|
||||
build_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
template <>
|
||||
struct BuilderTask<nodes::ExpressionProxy>
|
||||
: public BuilderTaskBase<nodes::ExpressionProxy> {
|
||||
using BuilderTaskBase<nodes::ExpressionProxy>::BuilderTaskBase;
|
||||
|
||||
nodes::Match build_match(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
nodes::ExpressionProxy operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
nodes::Condition build_condition(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
template <>
|
||||
struct BuilderTask<nodes::Match::Case>
|
||||
: public BuilderTaskBase<nodes::Match::Case> {
|
||||
using BuilderTaskBase<nodes::Match::Case>::BuilderTaskBase;
|
||||
|
||||
nodes::Loop build_loop(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
nodes::Match::Case operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct BuilderTask<nodes::Match> : public BuilderTaskBase<nodes::Match> {
|
||||
using BuilderTaskBase<nodes::Match>::BuilderTaskBase;
|
||||
|
||||
nodes::Match operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct BuilderTask<nodes::Condition>
|
||||
: public BuilderTaskBase<nodes::Condition> {
|
||||
using BuilderTaskBase<nodes::Condition>::BuilderTaskBase;
|
||||
|
||||
nodes::Condition operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct BuilderTask<nodes::Loop> : public BuilderTaskBase<nodes::Loop> {
|
||||
using BuilderTaskBase<nodes::Loop>::BuilderTaskBase;
|
||||
|
||||
nodes::Loop operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
// --- operators
|
||||
|
||||
nodes::NameExpression
|
||||
build_comma_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
template <>
|
||||
struct BuilderTask<nodes::NameExpression, utils::CommaTag>
|
||||
: public BuilderTaskBase<nodes::NameExpression> {
|
||||
using BuilderTaskBase<nodes::NameExpression>::BuilderTaskBase;
|
||||
|
||||
nodes::NameExpression
|
||||
build_operator_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
nodes::NameExpression operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct BuilderTask<nodes::NameExpression, utils::OperatorTag>
|
||||
: public BuilderTaskBase<nodes::NameExpression> {
|
||||
using BuilderTaskBase<nodes::NameExpression>::BuilderTaskBase;
|
||||
|
||||
nodes::NameExpression operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
// --- continers
|
||||
|
||||
nodes::Container build_block(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
template <typename T>
|
||||
requires std::is_same_v<T, utils::BlockTag> or
|
||||
std::is_same_v<T, utils::ArrayTag>
|
||||
struct BuilderTask<nodes::Container, T>
|
||||
: public BuilderTaskBase<nodes::Container> {
|
||||
using BuilderTaskBase<nodes::Container>::BuilderTaskBase;
|
||||
|
||||
nodes::Container build_array(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
// '{' (expression ';')* '}'
|
||||
// or
|
||||
// '[[' expression+ ']]'
|
||||
nodes::Container operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &) override {
|
||||
const auto container_type = std::is_same_v<T, utils::BlockTag>
|
||||
? nodes::Container::BLOCK
|
||||
: nodes::Container::ARRAY;
|
||||
|
||||
std::vector<nodes::ExpressionProxy> expressions;
|
||||
|
||||
auto current_node = parser_node.nth_named_child(0);
|
||||
|
||||
while (!current_node.is_null()) {
|
||||
expressions.push_back(Run<nodes::ExpressionProxy>(current_node));
|
||||
current_node = current_node.next_named_sibling();
|
||||
}
|
||||
|
||||
return nodes::Container(build_node(parser_node), container_type,
|
||||
std::move(expressions));
|
||||
}
|
||||
};
|
||||
|
||||
// --- modifiers
|
||||
|
||||
nodes::Return build_return(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
template <>
|
||||
struct BuilderTask<nodes::Return> : public BuilderTaskBase<nodes::Return> {
|
||||
using BuilderTaskBase<nodes::Return>::BuilderTaskBase;
|
||||
|
||||
nodes::NameDefinition
|
||||
build_name_definition(parser::ParseTree::Node parser_node);
|
||||
nodes::Return operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
nodes::Access build_array_access(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
template <>
|
||||
struct BuilderTask<nodes::NameDefinition>
|
||||
: public BuilderTaskBase<nodes::NameDefinition> {
|
||||
using BuilderTaskBase<nodes::NameDefinition>::BuilderTaskBase;
|
||||
|
||||
nodes::Access build_tuple_access(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
nodes::NameDefinition operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
nodes::LoopControl build_loop_control(parser::ParseTree::Node parser_node);
|
||||
template <>
|
||||
struct BuilderTask<nodes::Access, utils::ArrayAccessTag>
|
||||
: public BuilderTaskBase<nodes::Access> {
|
||||
using BuilderTaskBase<nodes::Access>::BuilderTaskBase;
|
||||
|
||||
nodes::ModifierExpression
|
||||
build_reference_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
nodes::Access operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
nodes::ModifierExpression
|
||||
build_suffix_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
template <>
|
||||
struct BuilderTask<nodes::Access, utils::TupleAccessTag>
|
||||
: public BuilderTaskBase<nodes::Access> {
|
||||
using BuilderTaskBase<nodes::Access>::BuilderTaskBase;
|
||||
|
||||
nodes::Access operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct BuilderTask<nodes::LoopControl>
|
||||
: public BuilderTaskBase<nodes::LoopControl> {
|
||||
using BuilderTaskBase<nodes::LoopControl>::BuilderTaskBase;
|
||||
|
||||
nodes::LoopControl operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
template <>
|
||||
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;
|
||||
};
|
||||
|
||||
template <>
|
||||
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;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
requires std::is_same_v<T, utils::RefTag> or
|
||||
std::is_same_v<T, utils::SuffixTag>
|
||||
struct BuilderTask<nodes::ModifierExpression, T>
|
||||
: public BuilderTaskBase<nodes::ModifierExpression> {
|
||||
using BuilderTaskBase<nodes::ModifierExpression>::BuilderTaskBase;
|
||||
|
||||
// _reference_ expression
|
||||
// or
|
||||
// expression ('?' | '!')
|
||||
nodes::ModifierExpression
|
||||
operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &) override {
|
||||
const size_t modifier_pos =
|
||||
std::is_same_v<T, utils::RefTag> ? 0 : parser_node.child_count() - 1;
|
||||
|
||||
return nodes::ModifierExpression(
|
||||
build_node(parser_node),
|
||||
build_modifier(parser_node.nth_child(modifier_pos)),
|
||||
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)));
|
||||
}
|
||||
};
|
||||
|
||||
// --- other
|
||||
|
||||
nodes::NameExpression
|
||||
build_name_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
template <>
|
||||
struct BuilderTask<nodes::NameExpression, utils::FuncCallTag>
|
||||
: public BuilderTaskBase<nodes::NameExpression> {
|
||||
using BuilderTaskBase<nodes::NameExpression>::BuilderTaskBase;
|
||||
|
||||
nodes::Constructor
|
||||
build_constructor(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
nodes::NameExpression operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
nodes::Lambda build_lambda(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage);
|
||||
template <>
|
||||
struct BuilderTask<nodes::Constructor>
|
||||
: public BuilderTaskBase<nodes::Constructor> {
|
||||
using BuilderTaskBase<nodes::Constructor>::BuilderTaskBase;
|
||||
|
||||
nodes::Constructor operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct BuilderTask<nodes::Lambda> : public BuilderTaskBase<nodes::Lambda> {
|
||||
using BuilderTaskBase<nodes::Lambda>::BuilderTaskBase;
|
||||
|
||||
nodes::Lambda operator()(const parser::ParseTree::Node &parser_node,
|
||||
const utils::None &args) override;
|
||||
};
|
||||
|
||||
} // namespace builders
|
||||
|
|
|
|||
|
|
@ -10,10 +10,8 @@
|
|||
|
||||
namespace builders {
|
||||
|
||||
nodes::ExpressionProxy
|
||||
build_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
nodes::ExpressionProxy BuilderTask<nodes::ExpressionProxy>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
tokens::Type type = tokens::string_to_type(parser_node.get_type());
|
||||
|
||||
auto maybe_parenthesis = parser_node.previous_sibling();
|
||||
|
|
@ -24,141 +22,128 @@ build_expression(parser::ParseTree::Node parser_node,
|
|||
switch (type) {
|
||||
// --- flow control
|
||||
case tokens::Type::MATCH:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_match(parser_node, expression_storage, type_storage), is_scoped));
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), Run<nodes::Match>(parser_node), is_scoped));
|
||||
case tokens::Type::CONDITION:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_condition(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
return state<Exprs>().add_expression(
|
||||
nodes::Expression(build_node(parser_node),
|
||||
Run<nodes::Condition>(parser_node), is_scoped));
|
||||
case tokens::Type::LOOP:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_loop(parser_node, expression_storage, type_storage), is_scoped));
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), Run<nodes::Loop>(parser_node), is_scoped));
|
||||
// --- operators
|
||||
case tokens::Type::COMMA_EXPRESSION:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_comma_expression(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
Run<nodes::NameExpression, utils::CommaTag>(parser_node), is_scoped));
|
||||
case tokens::Type::OPERATOR_EXPRESSION:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_node(parser_node),
|
||||
build_operator_expression(
|
||||
parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
Run<nodes::NameExpression, utils::OperatorTag>(parser_node),
|
||||
is_scoped));
|
||||
// --- containers
|
||||
case tokens::Type::BLOCK:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_block(parser_node, expression_storage, type_storage), is_scoped));
|
||||
Run<nodes::Container, utils::BlockTag>(parser_node), is_scoped));
|
||||
case tokens::Type::ARRAY:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_array(parser_node, expression_storage, type_storage), is_scoped));
|
||||
Run<nodes::Container, utils::ArrayTag>(parser_node), is_scoped));
|
||||
// --- modifiers
|
||||
case tokens::Type::RETURN:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_return(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), Run<nodes::Return>(parser_node), is_scoped));
|
||||
case tokens::Type::NAME_DEFINITION:
|
||||
return expression_storage.add_expression(
|
||||
return state<Exprs>().add_expression(
|
||||
nodes::Expression(build_node(parser_node),
|
||||
build_name_definition(parser_node), is_scoped));
|
||||
Run<nodes::NameDefinition>(parser_node), is_scoped));
|
||||
case tokens::Type::ARRAY_ACCESS:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_array_access(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
Run<nodes::Access, utils::ArrayAccessTag>(parser_node), is_scoped));
|
||||
case tokens::Type::TUPLE_ACCESS:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_tuple_access(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
Run<nodes::Access, utils::TupleAccessTag>(parser_node), is_scoped));
|
||||
case tokens::Type::LOOP_CONTROL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_loop_control(parser_node), is_scoped));
|
||||
case tokens::Type::REFERENCE_EXPRESSION:
|
||||
return expression_storage.add_expression(
|
||||
return state<Exprs>().add_expression(
|
||||
nodes::Expression(build_node(parser_node),
|
||||
build_reference_expression(
|
||||
parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
case tokens::Type::SUFFIX_EXPRESSION:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
Run<nodes::LoopControl>(parser_node), is_scoped));
|
||||
case tokens::Type::REFERENCE_EXPRESSION:
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_suffix_expression(parser_node, expression_storage, type_storage),
|
||||
Run<nodes::ModifierExpression, utils::RefTag>(parser_node), is_scoped));
|
||||
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));
|
||||
// --- other
|
||||
case tokens::Type::NAME_EXPRESSION:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_name_expression(parser_node, expression_storage, type_storage),
|
||||
Run<nodes::NameExpression, utils::FuncCallTag>(parser_node),
|
||||
is_scoped));
|
||||
case tokens::Type::ARGUMENT_NAME_IDENTIFIER:
|
||||
case tokens::Type::SIMPLE_NAME_IDENTIFIER:
|
||||
case tokens::Type::PLACEHOLDER:
|
||||
return expression_storage.add_expression(
|
||||
return state<Exprs>().add_expression(
|
||||
nodes::Expression(build_node(parser_node),
|
||||
nodes::NameExpression(build_node(parser_node),
|
||||
build_identifier(parser_node)),
|
||||
is_scoped));
|
||||
case tokens::Type::CONSTRUCTOR:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_constructor(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
return state<Exprs>().add_expression(
|
||||
nodes::Expression(build_node(parser_node),
|
||||
Run<nodes::Constructor>(parser_node), is_scoped));
|
||||
case tokens::Type::LAMBDA:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_lambda(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), Run<nodes::Lambda>(parser_node), is_scoped));
|
||||
// --- literals
|
||||
case tokens::Type::FLOAT_LITERAL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_float_literal(parser_node), is_scoped));
|
||||
case tokens::Type::DOUBLE_LITERAL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_double_literal(parser_node), is_scoped));
|
||||
case tokens::Type::INT_LITERAL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_int_literal(parser_node), is_scoped));
|
||||
case tokens::Type::LONG_LITERAL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_long_literal(parser_node), is_scoped));
|
||||
case tokens::Type::INDEX_LITERAL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_index_literal(parser_node), is_scoped));
|
||||
case tokens::Type::STRING_LITERAL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_string_literal(parser_node), is_scoped));
|
||||
case tokens::Type::UNICODE_STRING_LITERAL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_unicode_string_literal(parser_node),
|
||||
is_scoped));
|
||||
case tokens::Type::CHAR_LITERAL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_char_literal(parser_node), is_scoped));
|
||||
case tokens::Type::UNICODE_LITERAL:
|
||||
return expression_storage.add_expression(
|
||||
return state<Exprs>().add_expression(
|
||||
nodes::Expression(build_node(parser_node),
|
||||
build_unicode_literal(parser_node), is_scoped));
|
||||
case tokens::Type::BOOL_LITERAL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_bool_literal(parser_node), is_scoped));
|
||||
case tokens::Type::UNIT_LITERAL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_unit_literal(parser_node), is_scoped));
|
||||
case tokens::Type::NULL_LITERAL:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_null_literal(parser_node), is_scoped));
|
||||
case tokens::Type::EXTRA:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_extra(parser_node), is_scoped));
|
||||
case tokens::Type::EMPTY_LINES:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
return state<Exprs>().add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_empty_lines(parser_node), is_scoped));
|
||||
default:
|
||||
error_handling::handle_parsing_error("Unexprected expression node type",
|
||||
|
|
@ -172,9 +157,8 @@ build_expression(parser::ParseTree::Node parser_node,
|
|||
// --- flow control
|
||||
|
||||
// (':=' | '=:') expression (('??' | 'if') expression)? (_do_ expression)?
|
||||
nodes::Match::Case build_case(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
nodes::Match::Case BuilderTask<nodes::Match::Case>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
std::string case_type = parser_node.nth_child(0).get_value();
|
||||
|
||||
std::optional<parser::ParseTree::Node> condition_node;
|
||||
|
|
@ -198,41 +182,36 @@ nodes::Match::Case build_case(parser::ParseTree::Node parser_node,
|
|||
build_node(parser_node),
|
||||
case_type == ":=" ? nodes::Match::Case::PATTERN_VALUE
|
||||
: nodes::Match::Case::VALUE_PATTERN,
|
||||
build_expression(parser_node.nth_named_child(0), expression_storage,
|
||||
type_storage),
|
||||
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)),
|
||||
condition_node.has_value()
|
||||
? build_expression(condition_node.value(), expression_storage,
|
||||
type_storage)
|
||||
? Run<nodes::ExpressionProxy>(condition_node.value())
|
||||
: std::optional<nodes::ExpressionProxy>(),
|
||||
expression_node.has_value()
|
||||
? build_expression(expression_node.value(), expression_storage,
|
||||
type_storage)
|
||||
? Run<nodes::ExpressionProxy>(expression_node.value())
|
||||
: std::optional<nodes::ExpressionProxy>());
|
||||
}
|
||||
|
||||
// expression case+
|
||||
nodes::Match build_match(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
nodes::Match BuilderTask<nodes::Match>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
std::vector<nodes::Match::Case> cases;
|
||||
|
||||
auto current_node = parser_node.nth_named_child(1);
|
||||
while (!current_node.is_null()) {
|
||||
cases.push_back(build_case(current_node, expression_storage, type_storage));
|
||||
cases.push_back(Run<nodes::Match::Case>(current_node));
|
||||
current_node = current_node.next_named_sibling();
|
||||
}
|
||||
|
||||
return nodes::Match(build_node(parser_node),
|
||||
build_expression(parser_node.nth_named_child(0),
|
||||
expression_storage, type_storage),
|
||||
std::move(cases));
|
||||
return nodes::Match(
|
||||
build_node(parser_node),
|
||||
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)),
|
||||
std::move(cases));
|
||||
}
|
||||
|
||||
// ('??' | 'if') expression _do_ expression (('!!' | 'elif') expression _do_
|
||||
// expression)* (('!!=>', 'else') expression)?
|
||||
nodes::Condition build_condition(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
nodes::Condition BuilderTask<nodes::Condition>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
size_t named_child_count = parser_node.named_child_count();
|
||||
|
||||
std::vector<std::pair<nodes::ExpressionProxy, nodes::ExpressionProxy>> cases;
|
||||
|
|
@ -241,9 +220,8 @@ nodes::Condition build_condition(parser::ParseTree::Node parser_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, type_storage),
|
||||
build_expression(next_node, expression_storage, type_storage)});
|
||||
cases.push_back({Run<nodes::ExpressionProxy>(current_node),
|
||||
Run<nodes::ExpressionProxy>(next_node)});
|
||||
current_node = next_node.next_named_sibling();
|
||||
if (current_node.is_null()) {
|
||||
break;
|
||||
|
|
@ -254,35 +232,32 @@ nodes::Condition build_condition(parser::ParseTree::Node parser_node,
|
|||
return nodes::Condition(
|
||||
build_node(parser_node), std::move(cases),
|
||||
named_child_count % 2 == 1
|
||||
? build_expression(parser_node.nth_named_child(named_child_count - 1),
|
||||
expression_storage, type_storage)
|
||||
? Run<nodes::ExpressionProxy>(
|
||||
parser_node.nth_named_child(named_child_count - 1))
|
||||
: std::optional<nodes::ExpressionProxy>());
|
||||
}
|
||||
|
||||
// ('@' | 'for') (expression | expression ':' expression)? _do_ expression
|
||||
nodes::Loop build_loop(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
nodes::Loop
|
||||
BuilderTask<nodes::Loop>::operator()(const parser::ParseTree::Node &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),
|
||||
build_expression(parser_node.nth_named_child(0),
|
||||
expression_storage, type_storage));
|
||||
return nodes::Loop(
|
||||
build_node(parser_node),
|
||||
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)));
|
||||
} else if (named_child_count == 2) { // condition, body
|
||||
return nodes::Loop(build_node(parser_node),
|
||||
build_expression(parser_node.nth_named_child(0),
|
||||
expression_storage, type_storage),
|
||||
build_expression(parser_node.nth_named_child(1),
|
||||
expression_storage, type_storage));
|
||||
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
|
||||
return nodes::Loop(build_node(parser_node),
|
||||
build_expression(parser_node.nth_named_child(0),
|
||||
expression_storage, type_storage),
|
||||
build_expression(parser_node.nth_named_child(1),
|
||||
expression_storage, type_storage),
|
||||
build_expression(parser_node.nth_named_child(2),
|
||||
expression_storage, type_storage));
|
||||
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);
|
||||
|
|
@ -296,19 +271,16 @@ nodes::Loop build_loop(parser::ParseTree::Node parser_node,
|
|||
|
||||
// expression ',' expression
|
||||
nodes::NameExpression
|
||||
build_comma_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
BuilderTask<nodes::NameExpression, utils::CommaTag>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
std::vector<std::pair<std::optional<std::string>, nodes::ExpressionProxy>>
|
||||
arguments;
|
||||
|
||||
arguments.emplace_back(std::nullopt,
|
||||
build_expression(parser_node.nth_named_child(0),
|
||||
expression_storage, type_storage));
|
||||
arguments.emplace_back(std::nullopt, Run<nodes::ExpressionProxy>(
|
||||
parser_node.nth_named_child(0)));
|
||||
|
||||
arguments.emplace_back(std::nullopt,
|
||||
build_expression(parser_node.nth_named_child(1),
|
||||
expression_storage, type_storage));
|
||||
arguments.emplace_back(std::nullopt, Run<nodes::ExpressionProxy>(
|
||||
parser_node.nth_named_child(1)));
|
||||
|
||||
return nodes::NameExpression(
|
||||
build_node(parser_node),
|
||||
|
|
@ -320,21 +292,18 @@ build_comma_expression(parser::ParseTree::Node parser_node,
|
|||
|
||||
// expression operator expression
|
||||
nodes::NameExpression
|
||||
build_operator_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
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");
|
||||
|
||||
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, type_storage));
|
||||
arguments.emplace_back(std::nullopt, Run<nodes::ExpressionProxy>(
|
||||
name_node.previous_named_sibling()));
|
||||
|
||||
arguments.emplace_back(std::nullopt,
|
||||
build_expression(name_node.next_named_sibling(),
|
||||
expression_storage, type_storage));
|
||||
arguments.emplace_back(std::nullopt, Run<nodes::ExpressionProxy>(
|
||||
name_node.next_named_sibling()));
|
||||
|
||||
return nodes::NameExpression(build_node(parser_node),
|
||||
build_operator(name_node), std::move(arguments),
|
||||
|
|
@ -343,59 +312,24 @@ build_operator_expression(parser::ParseTree::Node parser_node,
|
|||
|
||||
// --- continers
|
||||
|
||||
nodes::Container
|
||||
build_container(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage,
|
||||
nodes::Container::ContainerType container_type) {
|
||||
std::vector<nodes::ExpressionProxy> expressions;
|
||||
|
||||
auto current_node = parser_node.nth_named_child(0);
|
||||
|
||||
while (!current_node.is_null()) {
|
||||
expressions.push_back(
|
||||
build_expression(current_node, expression_storage, type_storage));
|
||||
current_node = current_node.next_named_sibling();
|
||||
}
|
||||
|
||||
return nodes::Container(build_node(parser_node), container_type,
|
||||
std::move(expressions));
|
||||
}
|
||||
|
||||
// '{' (expression ';')* '}'
|
||||
nodes::Container build_block(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
return build_container(parser_node, expression_storage, type_storage,
|
||||
nodes::Container::BLOCK);
|
||||
}
|
||||
|
||||
// '[[' expression+ ']]'
|
||||
nodes::Container build_array(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
return build_container(parser_node, expression_storage, type_storage,
|
||||
nodes::Container::ARRAY);
|
||||
}
|
||||
// // Container -> .hpp
|
||||
|
||||
// --- modifiers
|
||||
|
||||
// ('return' | 'bring') expression
|
||||
nodes::Return build_return(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
nodes::Return BuilderTask<nodes::Return>::operator()(
|
||||
const parser::ParseTree::Node &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,
|
||||
build_expression(parser_node.nth_named_child(0),
|
||||
expression_storage, type_storage));
|
||||
return nodes::Return(
|
||||
build_node(parser_node),
|
||||
modifier == "return" ? nodes::Return::RETURN : nodes::Return::BRING,
|
||||
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)));
|
||||
}
|
||||
|
||||
// _var_let_ (simple_name_identifier | placeholder)
|
||||
nodes::NameDefinition
|
||||
build_name_definition(parser::ParseTree::Node parser_node) {
|
||||
nodes::NameDefinition BuilderTask<nodes::NameDefinition>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
std::string modifier = parser_node.nth_child(0).get_value();
|
||||
|
||||
auto name_node = parser_node.nth_named_child(0);
|
||||
|
|
@ -408,76 +342,41 @@ build_name_definition(parser::ParseTree::Node parser_node) {
|
|||
} // IN PROGRESS
|
||||
|
||||
// expression '[' expression ']'
|
||||
nodes::Access build_array_access(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
return nodes::Access(build_node(parser_node), nodes::Access::ARRAY,
|
||||
build_expression(parser_node.nth_named_child(0),
|
||||
expression_storage, type_storage),
|
||||
build_expression(parser_node.nth_named_child(1),
|
||||
expression_storage, type_storage));
|
||||
nodes::Access BuilderTask<nodes::Access, utils::ArrayAccessTag>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
return nodes::Access(
|
||||
build_node(parser_node), nodes::Access::ARRAY,
|
||||
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(0)),
|
||||
Run<nodes::ExpressionProxy>(parser_node.nth_named_child(1)));
|
||||
}
|
||||
|
||||
// expression '.' number_literal
|
||||
nodes::Access build_tuple_access(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
nodes::Access BuilderTask<nodes::Access, utils::TupleAccessTag>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
return nodes::Access(
|
||||
build_node(parser_node), nodes::Access::TUPLE,
|
||||
build_expression(parser_node.nth_named_child(0), expression_storage,
|
||||
type_storage),
|
||||
expression_storage.add_expression(nodes::Expression(
|
||||
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)));
|
||||
}
|
||||
|
||||
// 'break' | 'continue'
|
||||
nodes::LoopControl build_loop_control(parser::ParseTree::Node parser_node) {
|
||||
nodes::LoopControl BuilderTask<nodes::LoopControl>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
return nodes::LoopControl(build_node(parser_node),
|
||||
parser_node.get_value() == "break"
|
||||
? nodes::LoopControl::BREAK
|
||||
: nodes::LoopControl::CONTINUE);
|
||||
}
|
||||
|
||||
nodes::ModifierExpression
|
||||
build_modifier_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage,
|
||||
size_t modifier_position) {
|
||||
|
||||
return nodes::ModifierExpression(
|
||||
build_node(parser_node),
|
||||
build_modifier(parser_node.nth_child(modifier_position)),
|
||||
build_expression(parser_node.nth_named_child(0), expression_storage,
|
||||
type_storage));
|
||||
}
|
||||
|
||||
// _reference_ expression
|
||||
nodes::ModifierExpression
|
||||
build_reference_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
return build_modifier_expression(parser_node, expression_storage,
|
||||
type_storage, 0);
|
||||
}
|
||||
|
||||
// expression ('?' | '!')
|
||||
nodes::ModifierExpression
|
||||
build_suffix_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
return build_modifier_expression(parser_node, expression_storage,
|
||||
type_storage, parser_node.child_count() - 1);
|
||||
}
|
||||
// // ModifierExpression -> .hpp
|
||||
|
||||
// --- other
|
||||
|
||||
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) {
|
||||
parser::ParseTree::Node first_parse_node, Executor &executor,
|
||||
std::vector<nodes::AnnotatedArgument> &arguments) {
|
||||
|
||||
auto current_node = first_parse_node;
|
||||
|
||||
|
|
@ -489,7 +388,7 @@ void build_arguments_until_end(
|
|||
} else {
|
||||
arguments.emplace_back(
|
||||
std::move(last_annotation),
|
||||
build_expression(current_node, expression_storage, type_storage));
|
||||
executor.Run<nodes::ExpressionProxy>(current_node));
|
||||
last_annotation = std::nullopt;
|
||||
}
|
||||
current_node = current_node.next_named_sibling();
|
||||
|
|
@ -499,11 +398,9 @@ void build_arguments_until_end(
|
|||
// (type '.' simple_name | expression '.' simple_name | name | '(' operator
|
||||
// ')') (annotation? expression)*
|
||||
nodes::NameExpression
|
||||
build_name_expression(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
std::vector<std::pair<std::optional<std::string>, nodes::ExpressionProxy>>
|
||||
arguments;
|
||||
BuilderTask<nodes::NameExpression, utils::FuncCallTag>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
std::vector<nodes::AnnotatedArgument> arguments;
|
||||
|
||||
std::optional<nodes::Type> prefix;
|
||||
|
||||
|
|
@ -528,45 +425,40 @@ build_name_expression(parser::ParseTree::Node parser_node,
|
|||
prefix_node = current_node;
|
||||
} else {
|
||||
is_point_call = true;
|
||||
arguments.emplace_back(
|
||||
std::nullopt,
|
||||
build_expression(current_node, expression_storage, type_storage));
|
||||
arguments.emplace_back(std::nullopt,
|
||||
Run<nodes::ExpressionProxy>(current_node));
|
||||
}
|
||||
}
|
||||
|
||||
build_arguments_until_end(name_node.next_named_sibling(), expression_storage,
|
||||
type_storage, arguments);
|
||||
build_arguments_until_end(name_node.next_named_sibling(), executor,
|
||||
arguments);
|
||||
|
||||
return nodes::NameExpression(
|
||||
build_node(parser_node), build_identifier(name_node),
|
||||
std::move(arguments),
|
||||
prefix_node.has_value() ? build_type(prefix_node.value(), type_storage)
|
||||
prefix_node.has_value() ? build_type(prefix_node.value(), state<Types>())
|
||||
: nodes::MaybeTypeProxy(),
|
||||
is_point_call, false);
|
||||
}
|
||||
|
||||
// type (annotation? expression)*
|
||||
nodes::Constructor
|
||||
build_constructor(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
std::vector<std::pair<std::optional<std::string>, nodes::ExpressionProxy>>
|
||||
arguments;
|
||||
nodes::Constructor BuilderTask<nodes::Constructor>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
std::vector<nodes::AnnotatedArgument> arguments;
|
||||
|
||||
build_arguments_until_end(
|
||||
parser_node.child_by_field_name("type").next_named_sibling(),
|
||||
expression_storage, type_storage, arguments);
|
||||
parser_node.child_by_field_name("type").next_named_sibling(), executor,
|
||||
arguments);
|
||||
|
||||
return nodes::Constructor(
|
||||
build_node(parser_node),
|
||||
build_type(parser_node.child_by_field_name("type"), type_storage),
|
||||
build_type(parser_node.child_by_field_name("type"), state<Types>()),
|
||||
std::move(arguments));
|
||||
}
|
||||
|
||||
// '\\' argument_name* _do_ expression
|
||||
nodes::Lambda build_lambda(parser::ParseTree::Node parser_node,
|
||||
nodes::ExpressionStorage &expression_storage,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
nodes::Lambda BuilderTask<nodes::Lambda>::operator()(
|
||||
const parser::ParseTree::Node &parser_node, const utils::None &) {
|
||||
std::vector<nodes::Identifier> arguments;
|
||||
|
||||
auto current_node =
|
||||
|
|
@ -580,9 +472,8 @@ nodes::Lambda build_lambda(parser::ParseTree::Node parser_node,
|
|||
// skip '=>'
|
||||
current_node = current_node.next_named_sibling();
|
||||
|
||||
return nodes::Lambda(
|
||||
build_node(parser_node), std::move(arguments),
|
||||
build_expression(current_node, expression_storage, type_storage));
|
||||
return nodes::Lambda(build_node(parser_node), std::move(arguments),
|
||||
Run<nodes::ExpressionProxy>(current_node));
|
||||
}
|
||||
|
||||
} // namespace builders
|
||||
|
|
|
|||
|
|
@ -379,6 +379,9 @@ private:
|
|||
|
||||
// --- other
|
||||
|
||||
using AnnotatedArgument =
|
||||
std::pair<std::optional<std::string>, ExpressionProxy>;
|
||||
|
||||
class NameExpression : public TypedNode {
|
||||
public:
|
||||
NameExpression(Node node, Identifier &&name)
|
||||
|
|
@ -387,12 +390,10 @@ public:
|
|||
NameExpression(Node node, const Identifier &name)
|
||||
: TypedNode(node), name_(name) {}
|
||||
|
||||
NameExpression(
|
||||
Node node, Identifier &&name,
|
||||
std::vector<std::pair<std::optional<std::string>, ExpressionProxy>>
|
||||
&&arguments,
|
||||
std::optional<TypeProxy> &&prefix, bool is_point_call = false,
|
||||
bool is_operator_call = false)
|
||||
NameExpression(Node node, Identifier &&name,
|
||||
std::vector<AnnotatedArgument> &&arguments,
|
||||
std::optional<TypeProxy> &&prefix, bool is_point_call = false,
|
||||
bool is_operator_call = false)
|
||||
: TypedNode(node), name_(std::move(name)),
|
||||
arguments_(std::move(arguments)), prefix_(std::move(prefix)),
|
||||
is_point_call_(is_point_call), is_operator_call_(is_operator_call) {}
|
||||
|
|
@ -446,8 +447,7 @@ public:
|
|||
private:
|
||||
Identifier name_;
|
||||
// universal function call syntax
|
||||
std::vector<std::pair<std::optional<std::string>, ExpressionProxy>>
|
||||
arguments_;
|
||||
std::vector<AnnotatedArgument> arguments_;
|
||||
std::optional<TypeProxy> prefix_;
|
||||
// for static methods
|
||||
bool is_point_call_ = false; // x.f ... or f x ...
|
||||
|
|
@ -456,17 +456,13 @@ private:
|
|||
|
||||
class Constructor : public TypedNode {
|
||||
public:
|
||||
Constructor(
|
||||
Node node, TypeProxy type,
|
||||
std::vector<std::pair<std::optional<std::string>, ExpressionProxy>>
|
||||
&&arguments)
|
||||
Constructor(Node node, TypeProxy type,
|
||||
std::vector<AnnotatedArgument> &&arguments)
|
||||
: TypedNode(node), constructor_type_(type),
|
||||
arguments_(std::move(arguments)) {}
|
||||
|
||||
Constructor(
|
||||
Node node, TypeProxy type,
|
||||
const std::vector<std::pair<std::optional<std::string>, ExpressionProxy>>
|
||||
&arguments)
|
||||
Constructor(Node node, TypeProxy type,
|
||||
const std::vector<AnnotatedArgument> &arguments)
|
||||
: TypedNode(node), constructor_type_(type), arguments_(arguments) {}
|
||||
|
||||
Type *get_type() { return constructor_type_.get(); }
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue