From 8f96a818ff32fe7cd719b337f43ceba00135f45f Mon Sep 17 00:00:00 2001 From: ProgramSnail Date: Mon, 26 Aug 2024 21:38:02 +0300 Subject: [PATCH] arguments -> args --- lang/builders/include/builders_utils.hpp | 6 +- lang/builders/include/expression_builders.hpp | 34 +-- lang/builders/include/statement_builders.hpp | 12 +- lang/builders/src/expression_builders.cpp | 96 ++++---- lang/builders/src/statement_builders.cpp | 46 ++-- lang/nodes/include/expression_nodes.hpp | 73 +++--- lang/nodes/include/statement_nodes.hpp | 28 +-- lang/nodes/src/statement_nodes.cpp | 73 +++--- lang/printers/src/expression_printers.cpp | 6 +- lang/printers/src/statement_printers.cpp | 14 +- lang/type_check/include/basic_type_check.hpp | 3 +- .../include/expression_type_check.hpp | 44 ++-- lang/type_check/include/type_check_utils.hpp | 55 +++-- lang/type_check/src/basic_type_check.cpp | 4 +- lang/type_check/src/expression_type_check.cpp | 218 +++++++++--------- lang/type_check/src/type_check_utils.cpp | 35 ++- 16 files changed, 358 insertions(+), 389 deletions(-) diff --git a/lang/builders/include/builders_utils.hpp b/lang/builders/include/builders_utils.hpp index b4b79cf..cdd18ac 100644 --- a/lang/builders/include/builders_utils.hpp +++ b/lang/builders/include/builders_utils.hpp @@ -26,10 +26,10 @@ using ParserNode = parser::ParseTree::Node; // using Node = nodes::Node_>; // TODO -using Arguments = utils::None; +using Args = utils::None; template -using Task = utils::Task; +using Task = utils::Task; template struct BuilderTask { static_assert(false); @@ -39,7 +39,7 @@ template struct BuilderTaskBase : public Task { using Task::Task; template - OtherN Run(const parser::ParseTree::Node &node, const Arguments &args = {}) { + OtherN Run(const parser::ParseTree::Node &node, const Args &args = {}) { BuilderTask task(this->executor); return task(node, args); } diff --git a/lang/builders/include/expression_builders.hpp b/lang/builders/include/expression_builders.hpp index 0996877..65fdc27 100644 --- a/lang/builders/include/expression_builders.hpp +++ b/lang/builders/include/expression_builders.hpp @@ -28,7 +28,7 @@ struct BuilderTask : public BuilderTaskBase { using BuilderTaskBase::BuilderTaskBase; nodes::Expr operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -37,7 +37,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::Match::Case operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -45,7 +45,7 @@ struct BuilderTask : public BuilderTaskBase { using BuilderTaskBase::BuilderTaskBase; nodes::Match operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -54,7 +54,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::Condition operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -62,7 +62,7 @@ struct BuilderTask : public BuilderTaskBase { using BuilderTaskBase::BuilderTaskBase; nodes::Loop operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; // --- operators @@ -73,7 +73,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::NameExpression operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -82,7 +82,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::NameExpression operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; // --- continers @@ -98,7 +98,7 @@ struct BuilderTask // or // '[[' expression+ ']]' nodes::Container operator()(const ParserNode &parser_node, - const Arguments &) override { + const Args &) override { const auto container_type = std::is_same_v ? nodes::Container::BLOCK : nodes::Container::ARRAY; @@ -124,7 +124,7 @@ struct BuilderTask : public BuilderTaskBase { using BuilderTaskBase::BuilderTaskBase; nodes::Return operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -133,7 +133,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::NameDefinition operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -142,7 +142,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::Access operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -151,7 +151,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::Access operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -160,7 +160,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::LoopControl operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template @@ -174,7 +174,7 @@ struct BuilderTask // or // expression ('?' | '!') nodes::ModifierExpression operator()(const ParserNode &parser_node, - const Arguments &) override { + const Args &) override { const size_t modifier_pos = std::is_same_v ? 0 : parser_node.child_count() - 1; @@ -193,7 +193,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::NameExpression operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -202,7 +202,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::Constructor operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -210,7 +210,7 @@ struct BuilderTask : public BuilderTaskBase { using BuilderTaskBase::BuilderTaskBase; nodes::Lambda operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; } // namespace builders diff --git a/lang/builders/include/statement_builders.hpp b/lang/builders/include/statement_builders.hpp index 58ed0db..88c5e23 100644 --- a/lang/builders/include/statement_builders.hpp +++ b/lang/builders/include/statement_builders.hpp @@ -20,7 +20,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::Statements operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; // copy of statement inserted into name_tree @@ -30,7 +30,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::Statement operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -38,7 +38,7 @@ struct BuilderTask : public BuilderTaskBase { using BuilderTaskBase::BuilderTaskBase; nodes::Import operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -47,7 +47,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::Constraint operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -56,7 +56,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::TypeDefinition operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -65,7 +65,7 @@ struct BuilderTask using BuilderTaskBase::BuilderTaskBase; nodes::FunctionDefinition operator()(const ParserNode &parser_node, - const Arguments &args) override; + const Args &args) override; }; // const std::optional &previous_defined_type_name, // TODO diff --git a/lang/builders/src/expression_builders.cpp b/lang/builders/src/expression_builders.cpp index d4cfef2..9bb414c 100644 --- a/lang/builders/src/expression_builders.cpp +++ b/lang/builders/src/expression_builders.cpp @@ -11,7 +11,7 @@ namespace builders { nodes::Expr BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { tokens::Type type = tokens::string_to_type(parser_node.get_type()); auto maybe_parenthesis = parser_node.previous_sibling(); @@ -149,7 +149,7 @@ nodes::Expr BuilderTask::operator()(const ParserNode &parser_node, // (':=' | '=:') expression (('??' | 'if') expression)? (_do_ expression)? nodes::Match::Case BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { std::string case_type = parser_node.nth_child(0).get_value(); std::optional condition_node; @@ -183,7 +183,7 @@ BuilderTask::operator()(const ParserNode &parser_node, // expression case+ nodes::Match BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { std::vector cases; auto current_node = parser_node.nth_named_child(1); @@ -201,7 +201,7 @@ BuilderTask::operator()(const ParserNode &parser_node, // expression)* (('!!=>', 'else') expression)? nodes::Condition BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { size_t named_child_count = parser_node.named_child_count(); std::vector> cases; @@ -228,7 +228,7 @@ BuilderTask::operator()(const ParserNode &parser_node, // ('@' | 'for') (expression | expression ':' expression)? _do_ expression nodes::Loop BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { size_t named_child_count = parser_node.named_child_count(); if (named_child_count == 1) { // body @@ -274,41 +274,41 @@ nodes::Loop BuilderTask::operator()(const ParserNode &parser_node, // expression ',' expression nodes::NameExpression BuilderTask::operator()( - const ParserNode &parser_node, const Arguments &) { - std::vector, nodes::Expr>> arguments; + const ParserNode &parser_node, const Args &) { + std::vector, nodes::Expr>> args; - arguments.emplace_back(std::nullopt, - Run(parser_node.nth_named_child(0))); + args.emplace_back(std::nullopt, + Run(parser_node.nth_named_child(0))); - arguments.emplace_back(std::nullopt, - Run(parser_node.nth_named_child(1))); + args.emplace_back(std::nullopt, + Run(parser_node.nth_named_child(1))); return nodes::NameExpression( build_node(parser_node), nodes::Identifier( build_node(parser_node), // can't find more precise location nodes::Identifier::SIMPLE_NAME, ","), - std::move(arguments), std::nullopt, false, true); + std::move(args), std::nullopt, false, true); } // expression operator expression nodes::NameExpression BuilderTask::operator()( - const ParserNode &parser_node, const Arguments &) { + const ParserNode &parser_node, const Args &) { auto name_node = parser_node.child_by_field_name("na" "m" "e"); - std::vector, nodes::Expr>> arguments; + std::vector, nodes::Expr>> args; - arguments.emplace_back(std::nullopt, - Run(name_node.previous_named_sibling())); + args.emplace_back(std::nullopt, + Run(name_node.previous_named_sibling())); - arguments.emplace_back(std::nullopt, - Run(name_node.next_named_sibling())); + args.emplace_back(std::nullopt, + Run(name_node.next_named_sibling())); return nodes::NameExpression(build_node(parser_node), - build_operator(name_node), std::move(arguments), + build_operator(name_node), std::move(args), std::nullopt, false, true); } @@ -321,7 +321,7 @@ BuilderTask::operator()( // ('return' | 'bring') expression nodes::Return BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { std::string modifier = parser_node.nth_child(0).get_value(); return nodes::Return(build_node(parser_node), @@ -336,7 +336,7 @@ BuilderTask::operator()(const ParserNode &parser_node, // _var_let_ (simple_name_identifier | placeholder) nodes::NameDefinition BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { std::string modifier = parser_node.nth_child(0).get_value(); auto name_node = parser_node.nth_named_child(0); @@ -350,7 +350,7 @@ BuilderTask::operator()(const ParserNode &parser_node, // expression '[' expression ']' nodes::Access BuilderTask::operator()( - const ParserNode &parser_node, const Arguments &) { + const ParserNode &parser_node, const Args &) { return nodes::Access(build_node(parser_node), nodes::Access::ARRAY, Run(parser_node.nth_named_child(0)), Run(parser_node.nth_named_child(1))); @@ -358,7 +358,7 @@ nodes::Access BuilderTask::operator()( // expression '.' number_literal nodes::Access BuilderTask::operator()( - const ParserNode &parser_node, const Arguments &) { + const ParserNode &parser_node, const Args &) { return nodes::Access( build_node(parser_node), nodes::Access::TUPLE, Run(parser_node.nth_named_child(0)), @@ -370,7 +370,7 @@ nodes::Access BuilderTask::operator()( // 'break' | 'continue' nodes::LoopControl BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { return nodes::LoopControl(build_node(parser_node), parser_node.get_value() == "br" "ea" @@ -383,9 +383,8 @@ BuilderTask::operator()(const ParserNode &parser_node, // --- other -void build_arguments_until_end( - ParserNode first_parse_node, Executor &executor, - std::vector &arguments) { +void build_args_until_end(ParserNode first_parse_node, Executor &executor, + std::vector &args) { auto current_node = first_parse_node; std::optional last_annotation; @@ -394,9 +393,8 @@ void build_arguments_until_end( tokens::Type::ANNOTATION_IDENTIFIER) { last_annotation = build_annotation(current_node); } else { - arguments.emplace_back( - std::move(last_annotation), - BuilderTask{executor}(current_node, {})); + args.emplace_back(std::move(last_annotation), + BuilderTask{executor}(current_node, {})); last_annotation = std::nullopt; } current_node = current_node.next_named_sibling(); @@ -407,8 +405,8 @@ void build_arguments_until_end( // ')') (annotation? expression)* nodes::NameExpression BuilderTask::operator()( - const ParserNode &parser_node, const Arguments &) { - std::vector arguments; + const ParserNode &parser_node, const Args &) { + std::vector args; std::optional prefix; @@ -435,16 +433,14 @@ BuilderTask::operator()( prefix_node = current_node; } else { is_point_call = true; - arguments.emplace_back(std::nullopt, Run(current_node)); + args.emplace_back(std::nullopt, Run(current_node)); } } - build_arguments_until_end(name_node.next_named_sibling(), executor, - arguments); + build_args_until_end(name_node.next_named_sibling(), executor, args); return nodes::NameExpression( - build_node(parser_node), build_identifier(name_node), - std::move(arguments), + build_node(parser_node), build_identifier(name_node), std::move(args), prefix_node.has_value() ? build_type(prefix_node.value(), state()) : nodes::MaybeType(), is_point_call, false); @@ -453,40 +449,40 @@ BuilderTask::operator()( // type (annotation? expression)* nodes::Constructor BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { - std::vector arguments; + const Args &) { + std::vector args; - build_arguments_until_end(parser_node - .child_by_field_name("ty" - "p" - "e") - .next_named_sibling(), - executor, arguments); + build_args_until_end(parser_node + .child_by_field_name("ty" + "p" + "e") + .next_named_sibling(), + executor, args); return nodes::Constructor( build_node(parser_node), build_type(parser_node.child_by_field_name("type"), state()), - std::move(arguments)); + std::move(args)); } // '\\' argument_name* _do_ expression nodes::Lambda BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { - std::vector arguments; + const Args &) { + std::vector args; auto current_node = parser_node.nth_child(1); // next to '\\', not null ('=>' should present) while (current_node.is_named()) { // until _do_ - arguments.emplace_back(build_identifier(current_node)); + args.emplace_back(build_identifier(current_node)); current_node = current_node.next_sibling(); } // skip '=>' current_node = current_node.next_named_sibling(); - return nodes::Lambda(build_node(parser_node), std::move(arguments), + return nodes::Lambda(build_node(parser_node), std::move(args), Run(current_node)); } diff --git a/lang/builders/src/statement_builders.cpp b/lang/builders/src/statement_builders.cpp index ebb1a8e..88b8776 100644 --- a/lang/builders/src/statement_builders.cpp +++ b/lang/builders/src/statement_builders.cpp @@ -21,7 +21,7 @@ namespace builders { // statement+ nodes::Statements BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { std::vector statements; std::optional last_defined_type_name; @@ -38,7 +38,7 @@ BuilderTask::operator()(const ParserNode &parser_node, // import | type_definition | function_definition | typeclass_definition nodes::Statement BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { tokens::Type type = tokens::string_to_type(parser_node.get_type()); std::optional statement_name; @@ -108,7 +108,7 @@ BuilderTask::operator()(const ParserNode &parser_node, // ('::' | 'import') simple_name ('=' simple_name)? (':' identifier*)? nodes::Import BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { auto name_node = parser_node.child_by_field_name("name"); auto module_node = parser_node.child_by_field_name("module"); @@ -131,7 +131,7 @@ BuilderTask::operator()(const ParserNode &parser_node, // '?' expression nodes::Constraint BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { return nodes::Constraint(build_node(parser_node), Run(parser_node.nth_named_child(0))); } @@ -169,7 +169,7 @@ parser::ParseTree::Node collect_symbol_doc_nodes( // (argument_type* '=' type)? ';' nodes::TypeDefinition BuilderTask::operator()(const ParserNode &parser_node, - const Arguments &) { + const Args &) { std::optional description_node; std::vector annotation_nodes; @@ -194,7 +194,7 @@ BuilderTask::operator()(const ParserNode &parser_node, // std::vector typeclasses; - std::vector arguments; + std::vector args; std::optional type_node; @@ -205,7 +205,7 @@ BuilderTask::operator()(const ParserNode &parser_node, typeclasses.push_back(build_identifier(current_node)); break; case tokens::Type::ARGUMENT_TYPE_IDENTIFIER: - arguments.push_back(build_identifier(current_node)); + args.push_back(build_identifier(current_node)); break; case tokens::Type::VARIANT_TYPE: case tokens::Type::TUPLE_TYPE: @@ -231,7 +231,7 @@ BuilderTask::operator()(const ParserNode &parser_node, } if (is_typeclass) { - if (!arguments.empty()) { + if (!args.empty()) { error_handling::handle_parsing_error("Typeclass can't have arguments", parser_node); } @@ -258,7 +258,7 @@ BuilderTask::operator()(const ParserNode &parser_node, return nodes::TypeDefinition( build_node(parser_node), build_symbol_docs(description_node, annotation_nodes, annotations), - is_on_heap, std::move(name), std::move(typeclasses), std::move(arguments), + is_on_heap, std::move(name), std::move(typeclasses), std::move(args), type); } @@ -267,7 +267,7 @@ BuilderTask::operator()(const ParserNode &parser_node, // (annotation? _reference_ type)+)? // (((block | array) | '=' expression ';') | ';') nodes::FunctionDefinition BuilderTask::operator()( - const ParserNode &parser_node, const Arguments &) { + const ParserNode &parser_node, const Args &) { // const std::optional &last_defined_type_name, // TODO std::optional description_node; @@ -315,7 +315,7 @@ nodes::FunctionDefinition BuilderTask::operator()( } } - std::vector arguments; + std::vector args; std::vector argument_types; std::optional expression_node; @@ -362,7 +362,7 @@ nodes::FunctionDefinition BuilderTask::operator()( at_least_one_argument_annotation_found = true; } - arguments.push_back(nodes::FunctionDefinition::Argument( + args.push_back(nodes::FunctionDefinition::Argument( last_annotation, build_identifier(current_node), last_before_modifier, last_after_modifier)); @@ -373,12 +373,12 @@ nodes::FunctionDefinition BuilderTask::operator()( case tokens::Type::REFERENCE_TYPE: case tokens::Type::MODIFIED_TYPE: case tokens::Type::SIMPLE_TYPE: - if (current_type_id >= arguments.size()) { - arguments.push_back(nodes::FunctionDefinition::Argument( + if (current_type_id >= args.size()) { + args.push_back(nodes::FunctionDefinition::Argument( last_annotation, build_type(current_node, state()), last_before_modifier)); } else { - if (!arguments[current_type_id].add_type( + if (!args[current_type_id].add_type( last_annotation, build_type(current_node, state()), last_before_modifier)) { error_handling::handle_parsing_error( @@ -406,7 +406,7 @@ nodes::FunctionDefinition BuilderTask::operator()( current_node = current_node.next_named_sibling(); } - if (current_type_id > 0 && current_type_id < arguments.size()) { + if (current_type_id > 0 && current_type_id < args.size()) { error_handling::handle_parsing_error( "Less types then arguments in function definition", parser_node); } @@ -423,9 +423,9 @@ nodes::FunctionDefinition BuilderTask::operator()( (!at_least_one_argument_annotation_found && current_type_id == 0); if (are_annotations_same_to_names) { - for (size_t i = 0; i < arguments.size(); ++i) { - std::string new_annotation = *arguments[i].get_name().value()->get(); - if (!arguments[i].add_annotation( + for (size_t i = 0; i < args.size(); ++i) { + std::string new_annotation = *args[i].get_name().value()->get(); + if (!args[i].add_annotation( new_annotation.substr(1, new_annotation.size() - 1))) { error_handling::handle_parsing_error( "no annotations provided ( => all annotations same to names), but " @@ -436,9 +436,9 @@ nodes::FunctionDefinition BuilderTask::operator()( } std::unordered_set annotations_set; - for (auto &argument : arguments) { - if (argument.get_annotation().has_value()) { - if (!annotations_set.insert(*argument.get_annotation().value()).second) { + for (auto &arg : args) { + if (arg.get_annotation().has_value()) { + if (!annotations_set.insert(*arg.get_annotation().value()).second) { error_handling::handle_parsing_error( "Two or more same annotations found in function definition", parser_node); @@ -450,7 +450,7 @@ nodes::FunctionDefinition BuilderTask::operator()( build_node(parser_node), build_symbol_docs(description_node, annotation_nodes, annotations_set), std::move(constraints), return_modifier, is_method, name_prefix, - build_identifier(name_node), std::move(arguments), + build_identifier(name_node), std::move(args), are_annotations_same_to_names, expression_node.has_value() ? Run(expression_node.value()) : std::optional()); diff --git a/lang/nodes/include/expression_nodes.hpp b/lang/nodes/include/expression_nodes.hpp index ab4d584..24e5bc5 100644 --- a/lang/nodes/include/expression_nodes.hpp +++ b/lang/nodes/include/expression_nodes.hpp @@ -381,12 +381,12 @@ public: : TypedNode(node), name_(name) {} NameExpression(Node node, Identifier &&name, - std::vector &&arguments, + std::vector &&args, std::optional &&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) {} + : TypedNode(node), name_(std::move(name)), args_(std::move(args)), + prefix_(std::move(prefix)), is_point_call_(is_point_call), + is_operator_call_(is_operator_call) {} Identifier *get_name() { return &name_; } @@ -406,26 +406,24 @@ public: return std::nullopt; } - size_t arguments_size() const { return arguments_.size(); } + size_t args_size() const { return args_.size(); } - ExprData *get_argument_value(size_t id) { - return arguments_.at(id).second.get(); - } + ExprData *get_argument_value(size_t id) { return args_.at(id).second.get(); } const ExprData *get_argument_value(size_t id) const { - return arguments_.at(id).second.get(); + return args_.at(id).second.get(); } std::optional get_argument_annotation(size_t id) { - if (arguments_.at(id).first.has_value()) { - return &arguments_[id].first.value(); + if (args_.at(id).first.has_value()) { + return &args_[id].first.value(); } return std::nullopt; } std::optional get_argument_annotation(size_t id) const { - if (arguments_.at(id).first.has_value()) { - return &arguments_[id].first.value(); + if (args_.at(id).first.has_value()) { + return &args_[id].first.value(); } return std::nullopt; } @@ -437,7 +435,7 @@ public: private: Identifier name_; // universal function call syntax - std::vector arguments_; + std::vector args_; std::optional prefix_; // for static methods bool is_point_call_ = false; // x.f ... or f x ... @@ -446,13 +444,11 @@ private: class Constructor : public TypedNode { public: - Constructor(Node node, Type type, std::vector &&arguments) - : TypedNode(node), constructor_type_(type), - arguments_(std::move(arguments)) {} + Constructor(Node node, Type type, std::vector &&args) + : TypedNode(node), constructor_type_(type), args_(std::move(args)) {} - Constructor(Node node, Type type, - const std::vector &arguments) - : TypedNode(node), constructor_type_(type), arguments_(arguments) {} + Constructor(Node node, Type type, const std::vector &args) + : TypedNode(node), constructor_type_(type), args_(args) {} TypeData *get_type() { return constructor_type_.get(); } @@ -460,56 +456,53 @@ public: Type get_type_proxy() const { return constructor_type_; } - size_t arguments_size() const { return arguments_.size(); } + size_t args_size() const { return args_.size(); } - ExprData *get_argument_value(size_t id) { - return arguments_.at(id).second.get(); - } + ExprData *get_argument_value(size_t id) { return args_.at(id).second.get(); } const ExprData *get_argument_value(size_t id) const { - return arguments_.at(id).second.get(); + return args_.at(id).second.get(); } std::optional get_argument_annotation(size_t id) { - if (arguments_.at(id).first.has_value()) { - return &arguments_[id].first.value(); + if (args_.at(id).first.has_value()) { + return &args_[id].first.value(); } return std::nullopt; } std::optional get_argument_annotation(size_t id) const { - if (arguments_.at(id).first.has_value()) { - return &arguments_[id].first.value(); + if (args_.at(id).first.has_value()) { + return &args_[id].first.value(); } return std::nullopt; } private: Type constructor_type_; - std::vector, Expr>> arguments_; + std::vector, Expr>> args_; }; class Lambda : public TypedNode { public: - Lambda(Node node, std::vector &&arguments, Expr expression) - : TypedNode(node), arguments_(std::move(arguments)), - expression_(expression) {} + Lambda(Node node, std::vector &&args, Expr expression) + : TypedNode(node), args_(std::move(args)), expression_(expression) {} - Lambda(Node node, const std::vector &arguments, Expr expression) - : TypedNode(node), arguments_(arguments), expression_(expression) {} + Lambda(Node node, const std::vector &args, Expr expression) + : TypedNode(node), args_(args), expression_(expression) {} - size_t arguments_size() const { return arguments_.size(); } + size_t args_size() const { return args_.size(); } - Identifier *get_argument(size_t id) { return &arguments_.at(id); } + Identifier *get_argument(size_t id) { return &args_.at(id); } - const Identifier *get_argument(size_t id) const { return &arguments_.at(id); } + const Identifier *get_argument(size_t id) const { return &args_.at(id); } ExprData *get_expression() { return expression_.get(); } const ExprData *get_expression() const { return expression_.get(); } private: - std::vector arguments_; + std::vector args_; Expr expression_; }; @@ -521,7 +514,7 @@ public: // --- operators // CommaExpression is OperatorExpression for operator ',' - // OperatorExpression is NameExpression with two arguments + // OperatorExpression is NameExpression with two args // --- containers // Block value is brought value ("bring x") diff --git a/lang/nodes/include/statement_nodes.hpp b/lang/nodes/include/statement_nodes.hpp index ea933c1..e26c992 100644 --- a/lang/nodes/include/statement_nodes.hpp +++ b/lang/nodes/include/statement_nodes.hpp @@ -234,7 +234,7 @@ public: private: std::optional annotation_; - std::optional name_; // no name for output arguments + std::optional name_; // no name for output args std::optional type_; // no type if it is deduced Modifier before_modifier_ = Modifier::NONE; // in, out, ref, none // sync with type @@ -246,13 +246,13 @@ public: std::vector &&constraints, Modifier return_modifier, bool is_method, const std::optional &name_prefix, - const Identifier &name, std::vector &&arguments, + const Identifier &name, std::vector &&args, bool are_annotations_same_to_names, std::optional expression) : Node(node), docs_(std::move(docs)), constraints_(std::move(constraints)), return_modifier_(return_modifier), is_method_(is_method), name_(name), full_name_(name), - arguments_(std::move(arguments)), + args_(std::move(args)), are_annotations_same_to_names_(are_annotations_same_to_names), expression_(expression) { if (name_prefix.has_value()) { @@ -296,11 +296,11 @@ public: // - size_t arguments_size() const { return arguments_.size(); } + size_t args_size() const { return args_.size(); } - Argument *get_argument(size_t id) { return &arguments_.at(id); } + Argument *get_argument(size_t id) { return &args_.at(id); } - const Argument *get_argument(size_t id) const { return &arguments_.at(id); } + const Argument *get_argument(size_t id) const { return &args_.at(id); } // @@ -337,7 +337,7 @@ private: bool is_method_; Identifier name_; Identifier full_name_; - std::vector arguments_; + std::vector args_; bool are_annotations_same_to_names_; // needed for easier prinitng process std::optional expression_; }; // refactor ?? @@ -346,10 +346,10 @@ class TypeDefinition : public Node { public: TypeDefinition(Node node, SymbolDocs &&docs, bool is_on_heap, const Identifier &name, std::vector &&typeclasses, - std::vector &&arguments, std::optional type) + std::vector &&args, std::optional type) : Node(node), docs_(std::move(docs)), is_on_heap_(is_on_heap), - name_(name), typeclasses_(typeclasses), - arguments_(std::move(arguments)), type_(std::move(type)) {} + name_(name), typeclasses_(typeclasses), args_(std::move(args)), + type_(std::move(type)) {} // @@ -369,11 +369,11 @@ public: // - size_t arguments_size() const { return arguments_.size(); } + size_t args_size() const { return args_.size(); } - Identifier *get_argument(size_t id) { return &arguments_.at(id); } + Identifier *get_argument(size_t id) { return &args_.at(id); } - const Identifier *get_argument(size_t id) const { return &arguments_.at(id); } + const Identifier *get_argument(size_t id) const { return &args_.at(id); } // @@ -399,7 +399,7 @@ private: bool is_on_heap_; Identifier name_; std::vector typeclasses_; - std::vector arguments_; + std::vector args_; std::optional type_; }; diff --git a/lang/nodes/src/statement_nodes.cpp b/lang/nodes/src/statement_nodes.cpp index 22d4733..048d7de 100644 --- a/lang/nodes/src/statement_nodes.cpp +++ b/lang/nodes/src/statement_nodes.cpp @@ -56,64 +56,61 @@ CombineResult FunctionDefinition::combine(FunctionDefinition &&other) { return CombineResult::MORE_THEN_ONE_DOCS_ERROR; } - // check, that function definitions have same named arguments - for (size_t i = 0; i < std::max(arguments_.size(), other.arguments_.size()); - ++i) { - if (i < arguments_.size() && i < other.arguments_.size()) { + // check, that function definitions have same named args + for (size_t i = 0; i < std::max(args_.size(), other.args_.size()); ++i) { + if (i < args_.size() && i < other.args_.size()) { // annotations should be the same - if ((!arguments_[i].get_annotation().has_value() && - !other.arguments_[i].get_annotation().has_value()) || - (arguments_[i].get_annotation().has_value() && - other.arguments_[i].get_annotation().has_value() && - *arguments_[i].get_annotation().value() != - *other.arguments_[i].get_annotation().value())) { + if ((!args_[i].get_annotation().has_value() && + !other.args_[i].get_annotation().has_value()) || + (args_[i].get_annotation().has_value() && + other.args_[i].get_annotation().has_value() && + *args_[i].get_annotation().value() != + *other.args_[i].get_annotation().value())) { return CombineResult::ARGUMENTS_ERROR; } // argument names should be the same - if ((!arguments_[i].get_name().has_value() && - !other.arguments_[i].get_name().has_value()) || - (arguments_[i].get_name().has_value() && - other.arguments_[i].get_name().has_value() && - arguments_[i].get_name().value() != - other.arguments_[i].get_name().value())) { + if ((!args_[i].get_name().has_value() && + !other.args_[i].get_name().has_value()) || + (args_[i].get_name().has_value() && + other.args_[i].get_name().has_value() && + args_[i].get_name().value() != other.args_[i].get_name().value())) { return CombineResult::ARGUMENTS_ERROR; } // types should be the same (if present in both definitions) - if (arguments_[i].get_type().has_value() && - other.arguments_[i].get_type().has_value() && - *arguments_[i].get_type().value() != - *other.arguments_[i].get_type().value()) { + if (args_[i].get_type().has_value() && + other.args_[i].get_type().has_value() && + *args_[i].get_type().value() != *other.args_[i].get_type().value()) { return CombineResult::ARGUMENTS_ERROR; } // argument modifiers should be the same - if (arguments_[i].get_before_modifier() != - other.arguments_[i].get_before_modifier() || - arguments_[i].get_after_modifier() != - other.arguments_[i].get_after_modifier()) { + if (args_[i].get_before_modifier() != + other.args_[i].get_before_modifier() || + args_[i].get_after_modifier() != + other.args_[i].get_after_modifier()) { return CombineResult::ARGUMENTS_ERROR; } - } else if (i < arguments_.size()) { + } else if (i < args_.size()) { // annotations should be the same - if (arguments_[i].get_annotation().has_value()) { + if (args_[i].get_annotation().has_value()) { return CombineResult::ARGUMENTS_ERROR; } // names should be the same - if (arguments_[i].get_name().has_value()) { + if (args_[i].get_name().has_value()) { return CombineResult::ARGUMENTS_ERROR; } } else { // i < other_function_definition.size() // annotations should be the same - if (other.arguments_[i].get_annotation().has_value()) { + if (other.args_[i].get_annotation().has_value()) { return CombineResult::ARGUMENTS_ERROR; } // names should be the same - if (other.arguments_[i].get_name().has_value()) { + if (other.args_[i].get_name().has_value()) { return CombineResult::ARGUMENTS_ERROR; } } @@ -139,10 +136,10 @@ CombineResult FunctionDefinition::combine(FunctionDefinition &&other) { expression_ = other.expression_; } - for (size_t i = 0; i < other.arguments_.size(); ++i) { - if (i < arguments_.size()) { - if (other.arguments_[i].get_type().has_value()) { - if (arguments_[i].update_type_from(other.arguments_[i])) { + for (size_t i = 0; i < other.args_.size(); ++i) { + if (i < args_.size()) { + if (other.args_[i].get_type().has_value()) { + if (args_[i].update_type_from(other.args_[i])) { error_handling::handle_internal_error( "Function arguments are not properly checked before merging " "during combination", @@ -150,7 +147,7 @@ CombineResult FunctionDefinition::combine(FunctionDefinition &&other) { } } } else { - arguments_.push_back(std::move(other.arguments_[i])); + args_.push_back(std::move(other.args_[i])); } } @@ -189,12 +186,12 @@ CombineResult TypeDefinition::combine(TypeDefinition &&other) { } } - // arguments should be the same - if (arguments_.size() != other.arguments_.size()) { + // args should be the same + if (args_.size() != other.args_.size()) { return CombineResult::ARGUMENTS_ERROR; } - for (size_t i = 0; i < arguments_.size(); ++i) { - if (arguments_[i] != other.arguments_[i]) { + for (size_t i = 0; i < args_.size(); ++i) { + if (args_[i] != other.args_[i]) { return CombineResult::ARGUMENTS_ERROR; } } diff --git a/lang/printers/src/expression_printers.cpp b/lang/printers/src/expression_printers.cpp index f81a87e..c5c47ae 100644 --- a/lang/printers/src/expression_printers.cpp +++ b/lang/printers/src/expression_printers.cpp @@ -332,7 +332,7 @@ void print(const nodes::NameExpression &expression, for (size_t i = expression.is_operator_call() || expression.is_point_call() ? 1 : 0; - i < expression.arguments_size(); ++i) { + i < expression.args_size(); ++i) { if (!expression.is_operator_call() || !is_range_operator || i > 1) { printer.space(); } @@ -349,7 +349,7 @@ void print(const nodes::NameExpression &expression, void print(const nodes::Constructor &expression, printers::Printer &printer) { print(*expression.get_type(), printer); - for (size_t i = 0; i < expression.arguments_size(); ++i) { + for (size_t i = 0; i < expression.args_size(); ++i) { printer.space(); if (expression.get_argument_annotation(i).has_value()) { @@ -365,7 +365,7 @@ void print(const nodes::Constructor &expression, printers::Printer &printer) { void print(const nodes::Lambda &expression, printers::Printer &printer) { printer.print(printer.print_words_instead_of_symbols() ? "lambda " : "\\ "); - for (size_t i = 0; i < expression.arguments_size(); ++i) { + for (size_t i = 0; i < expression.args_size(); ++i) { print(*expression.get_argument(i), printer); printer.space(); } diff --git a/lang/printers/src/statement_printers.cpp b/lang/printers/src/statement_printers.cpp index 0647b08..1a09c32 100644 --- a/lang/printers/src/statement_printers.cpp +++ b/lang/printers/src/statement_printers.cpp @@ -74,7 +74,7 @@ void print(const nodes::TypeDefinition &statement, Printer &printer) { print(*statement.get_name(), printer); - for (size_t i = 0; i < statement.arguments_size(); ++i) { + for (size_t i = 0; i < statement.args_size(); ++i) { printer.space(); print(*statement.get_argument(i), printer); } @@ -121,14 +121,14 @@ void print(const nodes::FunctionDefinition &statement, Printer &printer) { print(statement.get_return_modifier(), printer); // ! or ? - for (size_t i = 0; i < statement.arguments_size(); ++i) { + for (size_t i = 0; i < statement.args_size(); ++i) { if (!statement.get_argument(i)->get_name().has_value()) { break; } printer.space(); - // all arguments are typed or are untyped in the same time + // all args are typed or are untyped in the same time if (!statement.get_argument(i)->get_type().has_value()) { // print annotation @@ -144,19 +144,19 @@ void print(const nodes::FunctionDefinition &statement, Printer &printer) { print(*statement.get_argument(i)->get_name().value(), printer); - // all arguments are typed or are untyped in the same time + // all args are typed or are untyped in the same time if (!statement.get_argument(i)->get_type().has_value()) { print(statement.get_argument(i)->get_after_modifier(), printer); } } - // all arguments are typed or are untyped in the same time - if (statement.arguments_size() > 0 && + // all args are typed or are untyped in the same time + if (statement.args_size() > 0 && statement.get_argument(0)->get_type().has_value()) { printer.print(" :"); - for (size_t i = 0; i < statement.arguments_size(); ++i) { + for (size_t i = 0; i < statement.args_size(); ++i) { printer.space(); if (statement.get_argument(i)->get_annotation().has_value()) { print_annotation(*statement.get_argument(i)->get_annotation().value(), diff --git a/lang/type_check/include/basic_type_check.hpp b/lang/type_check/include/basic_type_check.hpp index 17e3401..26bd15c 100644 --- a/lang/type_check/include/basic_type_check.hpp +++ b/lang/type_check/include/basic_type_check.hpp @@ -11,8 +11,7 @@ template <> struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result operator()(const nodes::Literal &literal, - const Arguments &arguments) override; + Result operator()(const nodes::Literal &literal, const Args &args) override; }; } // namespace type_check diff --git a/lang/type_check/include/expression_type_check.hpp b/lang/type_check/include/expression_type_check.hpp index 9194214..c77eb85 100644 --- a/lang/type_check/include/expression_type_check.hpp +++ b/lang/type_check/include/expression_type_check.hpp @@ -11,8 +11,7 @@ template <> struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result operator()(const nodes::ExprData &expr, - const Arguments &args) override; + Result operator()(const nodes::ExprData &expr, const Args &args) override; }; // --- flow control @@ -21,21 +20,20 @@ template <> struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result operator()(const nodes::Match &expr, const Arguments &args) override; + Result operator()(const nodes::Match &expr, const Args &args) override; }; template <> struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result operator()(const nodes::Condition &expr, - const Arguments &args) override; + Result operator()(const nodes::Condition &expr, const Args &args) override; }; template <> struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result operator()(const nodes::Loop &expr, const Arguments &args) override; + Result operator()(const nodes::Loop &expr, const Args &args) override; }; // --- containers @@ -44,12 +42,11 @@ template <> struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result CheckArray(const nodes::Container &expr, const Arguments &args); + Result CheckArray(const nodes::Container &expr, const Args &args); - Result CheckBlock(const nodes::Container &expr, const Arguments &args); + Result CheckBlock(const nodes::Container &expr, const Args &args); - Result operator()(const nodes::Container &expr, - const Arguments &args) override; + Result operator()(const nodes::Container &expr, const Args &args) override; }; // --- modifiers @@ -58,7 +55,7 @@ template <> struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result operator()(const nodes::Return &expr, const Arguments &args) override; + Result operator()(const nodes::Return &expr, const Args &args) override; }; template <> @@ -67,18 +64,18 @@ struct CheckTask using CheckTaskBase::CheckTaskBase; Result operator()(const nodes::NameDefinition &expr, - const Arguments &args) override; + const Args &args) override; }; template <> struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result CheckArrayAccess(const nodes::Access &expr, const Arguments &args); + Result CheckArrayAccess(const nodes::Access &expr, const Args &args); - Result CheckTupleAccess(const nodes::Access &expr, const Arguments &args); + Result CheckTupleAccess(const nodes::Access &expr, const Args &args); - Result operator()(const nodes::Access &expr, const Arguments &args) override; + Result operator()(const nodes::Access &expr, const Args &args) override; }; template <> @@ -86,8 +83,7 @@ struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result operator()(const nodes::LoopControl &expr, - const Arguments &args) override; + Result operator()(const nodes::LoopControl &expr, const Args &args) override; }; template <> @@ -96,7 +92,7 @@ struct CheckTask using CheckTaskBase::CheckTaskBase; Result operator()(const nodes::ModifierExpression &expr, - const Arguments &args) override; + const Args &args) override; }; // --- other @@ -107,7 +103,7 @@ struct CheckTask using CheckTaskBase::CheckTaskBase; Result operator()(const nodes::NameExpression &expr, - const Arguments &args) override; + const Args &args) override; }; template <> @@ -115,30 +111,28 @@ struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result operator()(const nodes::Constructor &expr, - const Arguments &args) override; + Result operator()(const nodes::Constructor &expr, const Args &args) override; }; template <> struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result operator()(const nodes::Lambda &expr, const Arguments &args) override; + Result operator()(const nodes::Lambda &expr, const Args &args) override; }; template <> struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result operator()(const nodes::Extra &expr, const Arguments &args) override; + Result operator()(const nodes::Extra &expr, const Args &args) override; }; template <> struct CheckTask : public CheckTaskBase { using CheckTaskBase::CheckTaskBase; - Result operator()(const nodes::EmptyLines &expr, - const Arguments &args) override; + Result operator()(const nodes::EmptyLines &expr, const Args &args) override; }; } // namespace type_check diff --git a/lang/type_check/include/type_check_utils.hpp b/lang/type_check/include/type_check_utils.hpp index 7cb3574..93fcd75 100644 --- a/lang/type_check/include/type_check_utils.hpp +++ b/lang/type_check/include/type_check_utils.hpp @@ -167,49 +167,49 @@ using Executor = utils::Executor; // -class Arguments { +class Args { public: - Arguments() = default; + Args() = default; - Arguments expect_builtin(builtin::Type type, Executor &executor) const { - Arguments copy(*this); + Args expect_builtin(builtin::Type type, Executor &executor) const { + Args copy(*this); copy.expected_types_ = {executor.state().primitive(type)}; return copy; } - Arguments pass_builtin(builtin::Type type, Executor &executor) const { - Arguments copy(*this); + Args pass_builtin(builtin::Type type, Executor &executor) const { + Args copy(*this); copy.passed_type_ = executor.state().primitive(type); return copy; } - Arguments expect(nodes::Types types) const { - Arguments copy(*this); + Args expect(nodes::Types types) const { + Args copy(*this); copy.expected_types_ = types; return copy; } - Arguments expect(nodes::MaybeType type) const { - Arguments copy(*this); + Args expect(nodes::MaybeType type) const { + Args copy(*this); copy.expected_types_ = (type.has_value() ? nodes::Types{type.value()} : nodes::Types{}); return copy; } - Arguments pass(nodes::MaybeType type) const { - Arguments copy(*this); + Args pass(nodes::MaybeType type) const { + Args copy(*this); copy.passed_type_ = type; return copy; } - Arguments without_expect() const { - Arguments copy(*this); + Args without_expect() const { + Args copy(*this); copy.expected_types_ = {}; return copy; } - Arguments without_pass() const { - Arguments copy(*this); + Args without_pass() const { + Args copy(*this); copy.passed_type_ = {}; return copy; } @@ -219,7 +219,7 @@ public: nodes::MaybeType get_passed() const { return passed_type_; }; // TODO: add check, that there is no passed type for some nodes ?? - // TODO: arguments builder ?? + // TODO: args builder ?? private: nodes::Types expected_types_; @@ -298,26 +298,26 @@ using MaybeResult = std::optional; // -nodes::Type check_same_to_pass_type_in_arguments( - nodes::Type type, const Arguments &arguments, const nodes::Node &node, +nodes::Type check_same_to_pass_type_in_args( + nodes::Type type, const Args &args, const nodes::Node &node, Executor &executor, const std::string &message = "Different type with passed one", bool handle_errors = true); -// bool check_no_pass_type_in_arguments( -// const Arguments &arguments, const nodes::Node &node, +// bool check_no_pass_type_in_args( +// const Args &args, const nodes::Node &node, // SourcesManager &sources_manager, // const std::string &message = "Type can't be passed to this node"); Result type_same_to_expected( - nodes::Type type, const Arguments &argumensr, const nodes::Node &node, + nodes::Type type, const Args &argumensr, const nodes::Node &node, Executor &executor, const std::string &message = "Different type with expected one", bool handle_errors = true); -Result type_check_from_arguments(nodes::Type type, const Arguments &arguments, - const nodes::Node &node, Executor &executor, - bool handle_errors = true); +Result type_check_from_args(nodes::Type type, const Args &args, + const nodes::Node &node, Executor &executor, + bool handle_errors = true); std::optional find_type_definition(const std::string &name, const nodes::Node &node, @@ -343,7 +343,7 @@ void type_check_error(const std::string &message, const nodes::Node &node, // -template using Task = utils::Task; +template using Task = utils::Task; template struct CheckTask { static_assert(false); @@ -352,8 +352,7 @@ template struct CheckTask { template struct CheckTaskBase : public Task { using Task::Task; - template - Result Run(const OtherN &node, const Arguments &args) { + template Result Run(const OtherN &node, const Args &args) { CheckTask task(this->executor); return task(node, args); } diff --git a/lang/type_check/src/basic_type_check.cpp b/lang/type_check/src/basic_type_check.cpp index 6a06cbc..79c83af 100644 --- a/lang/type_check/src/basic_type_check.cpp +++ b/lang/type_check/src/basic_type_check.cpp @@ -38,9 +38,9 @@ nodes::Type get_literal_type(const nodes::Literal &literal, } Result CheckTask::operator()(const nodes::Literal &literal, - const Arguments &arguments) { + const Args &args) { auto const type = get_literal_type(literal, this->executor); - return type_same_to_expected(type, arguments, literal, this->executor); + return type_same_to_expected(type, args, literal, this->executor); } } // namespace type_check diff --git a/lang/type_check/src/expression_type_check.cpp b/lang/type_check/src/expression_type_check.cpp index 8a7bbb0..ab09a16 100644 --- a/lang/type_check/src/expression_type_check.cpp +++ b/lang/type_check/src/expression_type_check.cpp @@ -12,18 +12,16 @@ namespace type_check { Result CheckTask::operator()(const nodes::ExprData &expr, - const Arguments &arguments) { + const Args &args) { return std::visit( - [this, &arguments](const auto &node) -> Result { - return Run(node, arguments); - }, + [this, &args](const auto &node) -> Result { return Run(node, args); }, expr.get_any()); } // --- flow control Result CheckTask::operator()(const nodes::Match &expr, - const Arguments &args) { + const Args &args) { Result value_result = Run(*expr.get_value(), {}); // x :=/=: ... @@ -41,7 +39,7 @@ Result CheckTask::operator()(const nodes::Match &expr, // :=/=: x ... Run(*current_case->get_value(), - Arguments{} + Args{} .expect_builtin(builtin::Type::BOOL, executor) .pass(value_result.is_invalid() ? nodes::MaybeType{} : expression_result.value().get())); @@ -50,7 +48,7 @@ Result CheckTask::operator()(const nodes::Match &expr, // ... ?? x ... if (current_case->get_condition().has_value()) { Run(*current_case->get_condition().value(), - Arguments{}.expect_builtin(builtin::Type::BOOL, executor)); + Args{}.expect_builtin(builtin::Type::BOOL, executor)); } // ... -> x @@ -58,9 +56,9 @@ Result CheckTask::operator()(const nodes::Match &expr, at_least_one_case_with_expression = true; Result case_result = Run(*current_case->get_condition().value(), - Arguments{}.expect(expression_result.has_value() - ? expression_result.value().get() - : nodes::MaybeType{})); + Args{}.expect(expression_result.has_value() + ? expression_result.value().get() + : nodes::MaybeType{})); if (!expression_result.has_value() && !case_result.is_invalid()) { expression_result = std::move(case_result); @@ -82,24 +80,23 @@ Result CheckTask::operator()(const nodes::Match &expr, expression_result = Result{state().primitive(builtin::Type::UNIT)}; } - return type_check_from_arguments( + return type_check_from_args( state().add_array_of(expression_result.value().get()), args, expr, executor); } Result CheckTask::operator()(const nodes::Condition &expr, - const Arguments &args) { + const Args &args) { MaybeResult expression_result; for (size_t i = 0; i < expr.cases_size(); ++i) { Run(*expr.get_case(i).first, - Arguments{}.expect_builtin(builtin::Type::BOOL, executor)); + Args{}.expect_builtin(builtin::Type::BOOL, executor)); - Result case_result = - Run(*expr.get_case(i).first, - Arguments{}.expect(expression_result.has_value() - ? expression_result.value().get() - : nodes::MaybeType{})); + Result case_result = Run(*expr.get_case(i).first, + Args{}.expect(expression_result.has_value() + ? expression_result.value().get() + : nodes::MaybeType{})); if (!expression_result.has_value() && !case_result.is_invalid()) { expression_result = std::move(case_result); @@ -108,9 +105,9 @@ Result CheckTask::operator()(const nodes::Condition &expr, if (expr.get_else_case().has_value()) { Run(*expr.get_else_case().value(), - Arguments{}.expect(expression_result.has_value() - ? expression_result.value().get() - : nodes::MaybeType{})); + Args{}.expect(expression_result.has_value() + ? expression_result.value().get() + : nodes::MaybeType{})); } if (!expression_result.has_value()) { @@ -119,13 +116,13 @@ Result CheckTask::operator()(const nodes::Condition &expr, expression_result = Result::invalid(); } - return type_check_from_arguments( + return type_check_from_args( state().add_array_of(expression_result.value().get()), args, expr, executor); } Result CheckTask::operator()(const nodes::Loop &expr, - const Arguments &args) { + const Args &args) { // TODO: ranges ?? MaybeResult interval_result; @@ -139,7 +136,7 @@ Result CheckTask::operator()(const nodes::Loop &expr, break; case nodes::Loop::WHILE: Run(*expr.get_condition().value(), - Arguments{}.expect_builtin(builtin::Type::BOOL, executor)); + Args{}.expect_builtin(builtin::Type::BOOL, executor)); // --- type check is independent from loop itself --- // if (condition_result.value().is_invalid()) { @@ -151,7 +148,7 @@ Result CheckTask::operator()(const nodes::Loop &expr, // TODO: expect range ?? interval_result = Run(*expr.get_interval().value(), - Arguments{}.expect_builtin(builtin::Type::ARRAY, executor)); + Args{}.expect_builtin(builtin::Type::ARRAY, executor)); if (interval_result.value().is_invalid()) { // --- type check is independent from loop itself --- @@ -161,7 +158,7 @@ Result CheckTask::operator()(const nodes::Loop &expr, variable_result = Run(*expr.get_variable().value(), - Arguments{}.expect( + Args{}.expect( interval_result.value().get().get()->get_parameter_proxy(0))); // --- type check is independent from loop itself --- @@ -177,7 +174,7 @@ Result CheckTask::operator()(const nodes::Loop &expr, // TODO: modifier checks ??, modifiers ?? - return type_check_from_arguments( + return type_check_from_args( state().add_array_of(expression_result.get()), args, expr, executor); } // IN PROGRESS @@ -185,7 +182,7 @@ Result CheckTask::operator()(const nodes::Loop &expr, // --- containers Result CheckTask::CheckArray(const nodes::Container &expr, - const Arguments &args) { + const Args &args) { MaybeResult last_expression_result; for (size_t i = 0; i < expr.expressions_size(); ++i) { @@ -209,13 +206,13 @@ Result CheckTask::CheckArray(const nodes::Container &expr, return Result::invalid(); } - return type_check_from_arguments( + return type_check_from_args( state().add_array_of(last_expression_result.value().get()), args, expr, executor); } Result CheckTask::CheckBlock(const nodes::Container &expr, - const Arguments &args) { + const Args &args) { nodes::MaybeType context_exit_type; { @@ -234,13 +231,13 @@ Result CheckTask::CheckBlock(const nodes::Container &expr, ? Result(context_exit_type.value()) : Result(state().primitive(builtin::Type::UNIT)); - return type_check_from_arguments( + return type_check_from_args( state().add_array_of(block_brought_type.get()), args, expr, executor); } Result CheckTask::operator()(const nodes::Container &expr, - const Arguments &args) { + const Args &args) { switch (expr.get_type()) { case nodes::Container::ARRAY: return CheckArray(expr, args); @@ -252,7 +249,7 @@ Result CheckTask::operator()(const nodes::Container &expr, // --- modifiers Result CheckTask::operator()(const nodes::Return &expr, - const Arguments &args) { + const Args &args) { auto returned_result = Run(*expr.get_expression(), {}); if (returned_result.is_invalid()) { @@ -275,14 +272,14 @@ Result CheckTask::operator()(const nodes::Return &expr, break; } - return type_check_from_arguments( - state().primitive(builtin::Type::UNIT), args, expr, executor); + return type_check_from_args(state().primitive(builtin::Type::UNIT), + args, expr, executor); } // TODO: warning if name is same to package prefix, function prefix, etc. ?? Result CheckTask::operator()(const nodes::NameDefinition &expr, - const Arguments &args) { + const Args &args) { if (!args.get_passed().has_value()) { type_check_error("Can't deduce type of new variable from context", expr, executor); @@ -307,19 +304,17 @@ CheckTask::operator()(const nodes::NameDefinition &expr, } // Return BOOL as any := / =: expression - return type_check_from_arguments( - state().primitive(builtin::Type::BOOL), args, expr, executor); + return type_check_from_args(state().primitive(builtin::Type::BOOL), + args, expr, executor); } Result CheckTask::CheckArrayAccess(const nodes::Access &expr, - const Arguments &args) { - auto index_result = - Run(*expr.get_index(), - Arguments{}.expect_builtin(builtin::Type::INDEX, executor)); + const Args &args) { + auto index_result = Run( + *expr.get_index(), Args{}.expect_builtin(builtin::Type::INDEX, executor)); - auto value_result = - Run(*expr.get_value(), - Arguments{}.expect_builtin(builtin::Type::ARRAY, executor)); + auto value_result = Run( + *expr.get_value(), Args{}.expect_builtin(builtin::Type::ARRAY, executor)); if (index_result.is_invalid()) { return index_result; @@ -331,15 +326,14 @@ Result CheckTask::CheckArrayAccess(const nodes::Access &expr, // TODO: modifier checks ?? - return type_check_from_arguments( - value_result.get().get()->get_parameter_proxy(0), args, expr, executor); + return type_check_from_args(value_result.get().get()->get_parameter_proxy(0), + args, expr, executor); } Result CheckTask::CheckTupleAccess(const nodes::Access &expr, - const Arguments &args) { - auto value_result = - Run(*expr.get_value(), - Arguments{}.expect_builtin(builtin::Type::TUPLE, executor)); + const Args &args) { + auto value_result = Run( + *expr.get_value(), Args{}.expect_builtin(builtin::Type::TUPLE, executor)); if (value_result.is_invalid()) { return value_result; @@ -353,13 +347,13 @@ Result CheckTask::CheckTupleAccess(const nodes::Access &expr, // TODO: modifier checks ?? - return type_check_from_arguments( + return type_check_from_args( value_result.get().get()->get_parameter_proxy(index), args, expr, executor); } Result CheckTask::operator()(const nodes::Access &expr, - const Arguments &args) { + const Args &args) { switch (expr.get_type()) { case nodes::Access::ARRAY: return CheckArrayAccess(expr, args); @@ -369,13 +363,13 @@ Result CheckTask::operator()(const nodes::Access &expr, } Result CheckTask::operator()(const nodes::LoopControl &expr, - const Arguments &args) { - return type_check_from_arguments( - state().primitive(builtin::Type::UNIT), args, expr, executor); + const Args &args) { + return type_check_from_args(state().primitive(builtin::Type::UNIT), + args, expr, executor); } Result CheckTask::operator()( - const nodes::ModifierExpression &expr, const Arguments &args) { + const nodes::ModifierExpression &expr, const Args &args) { auto modified_result = Run(*expr.get_expression(), {}); if (modified_result.is_invalid()) { @@ -407,7 +401,7 @@ Result CheckTask::operator()( modified_result.get(), expr.get_modifier())); } - return type_check_from_arguments(modified_result.get(), args, expr, executor); + return type_check_from_args(modified_result.get(), args, expr, executor); } // IN PROGRESS // --- other @@ -415,7 +409,7 @@ Result CheckTask::operator()( // TODO Result CheckTask::operator()(const nodes::NameExpression &expr, - const Arguments &args) { + const Args &args) { // TODO: constraints ?? const auto name = expr.get_name(); @@ -488,16 +482,16 @@ CheckTask::operator()(const nodes::NameExpression &expr, // TODO: count passed type, if needed // TODO: manage situation with one out type at any position // TODO + 1 - returned type - somtimes (can be ==) - const auto arguments_given = expr.arguments_size(); - const auto arguments_defined = function_definition->arguments_size(); - if (arguments_given + 1 < arguments_defined || - arguments_given > arguments_defined) { // other, when there is passed type + const auto args_given = expr.args_size(); + const auto args_defined = function_definition->args_size(); + if (args_given + 1 < args_defined || + args_given > args_defined) { // other, when there is passed type type_check_error( - "Number of function arguments is different from expected (" + - std::to_string(arguments_given) + " instead of " + - std::to_string(arguments_defined) + - std::string{arguments_defined > 0 - ? (" or " + std::to_string(arguments_defined - 1)) + "Number of function args is different from expected (" + + std::to_string(args_given) + " instead of " + + std::to_string(args_defined) + + std::string{args_defined > 0 + ? (" or " + std::to_string(args_defined - 1)) : ""} + ")", expr, executor); @@ -508,7 +502,7 @@ CheckTask::operator()(const nodes::NameExpression &expr, // TODO: define types for generic function std::vector function_argument_results; - for (size_t i = 0; i < arguments_given; + for (size_t i = 0; i < args_given; ++i) { // TODO: pass types with oud modifier const nodes::FunctionDefinition::Argument *argument = function_definition->get_argument(i); @@ -541,10 +535,10 @@ CheckTask::operator()(const nodes::NameExpression &expr, function_argument_results.push_back( Run(*expr.get_argument_value(i), - Arguments{}.expect(argument->get_type_proxy().value()))); + Args{}.expect(argument->get_type_proxy().value()))); } - if (function_definition->arguments_size() == 0) { + if (function_definition->args_size() == 0) { type_check_error( "Function arguments size is zero. Returned type is not defined", expr, executor); @@ -552,11 +546,10 @@ CheckTask::operator()(const nodes::NameExpression &expr, } // TODO: check condition - if (arguments_given + 1 == arguments_defined) { + if (args_given + 1 == args_defined) { // returned type const nodes::FunctionDefinition::Argument *returned = - function_definition->get_argument( - function_definition->arguments_size() - 1); + function_definition->get_argument(function_definition->args_size() - 1); // TODO: invert modifier ?? if (!returned->get_type().has_value()) { @@ -567,9 +560,9 @@ CheckTask::operator()(const nodes::NameExpression &expr, } // TODO: invert modifier ?? - // TODO: generic types should be deduced from arguments - return type_check_from_arguments(returned->get_type_proxy().value(), args, - expr, executor); + // TODO: generic types should be deduced from args + return type_check_from_args(returned->get_type_proxy().value(), args, expr, + executor); } // checks for universal call syntax ?? @@ -579,7 +572,7 @@ CheckTask::operator()(const nodes::NameExpression &expr, // TODO Result CheckTask::operator()(const nodes::Constructor &expr, - const Arguments &args) { + const Args &args) { // TODO: constraints ?? // TODO: use pass type @@ -605,7 +598,7 @@ Result CheckTask::operator()(const nodes::Constructor &expr, // TODO: work with different parametric types: tuple, variant, ... - if (expr.arguments_size() == 0) { + if (expr.args_size() == 0) { type_check_error("Number of type constructor arguments should be > 0", expr, executor); return Result::invalid(); @@ -613,18 +606,18 @@ Result CheckTask::operator()(const nodes::Constructor &expr, // generic) } - // TODO: work with generics (type_definition->arguments, ...) + // TODO: work with generics (type_definition->args, ...) const auto builtin_type = type.get()->to_builtin(); - { // check arguments size, ets. + { // check args size, ets. switch (builtin_type) { case builtin::Type::TUPLE: - if (expr.arguments_size() != type.get()->parameters_size()) { + if (expr.args_size() != type.get()->parameters_size()) { type_check_error( "Number of type constructor arguments is different from expected " "(" + - std::to_string(expr.arguments_size()) + " instead of " + + std::to_string(expr.args_size()) + " instead of " + std::to_string(type.get()->parameters_size()) + ")", expr, executor); return Result::invalid(); @@ -638,7 +631,7 @@ Result CheckTask::operator()(const nodes::Constructor &expr, case builtin::Type::ERROR: case builtin::Type::FUNCTION: case builtin::Type::NONE: - if (expr.arguments_size() != 1) { // TODO: better to_string + if (expr.args_size() != 1) { // TODO: better to_string type_check_error("Number of type constructor arguments should be = 1 " "(builtin type " + std::to_string(uint(builtin_type)) + ")", @@ -717,7 +710,7 @@ Result CheckTask::operator()(const nodes::Constructor &expr, switch (builtin_type) { case builtin::Type::TUPLE: - for (size_t i = 0; i < expr.arguments_size(); ++i) { + for (size_t i = 0; i < expr.args_size(); ++i) { check_same_annotation(i, type.get()->get_parameter(i)->get_annotation(), true /*log errors*/); } @@ -755,18 +748,18 @@ Result CheckTask::operator()(const nodes::Constructor &expr, } } - { // type check arguments + { // type check args switch (builtin_type) { case builtin::Type::TUPLE: - for (size_t i = 0; i < expr.arguments_size(); ++i) { + for (size_t i = 0; i < expr.args_size(); ++i) { Run(*expr.get_argument_value(i), - Arguments{}.expect(type.get()->get_parameter_proxy(i))); + Args{}.expect(type.get()->get_parameter_proxy(i))); } break; case builtin::Type::VARIANT: if (chosen_variant_option.has_value()) { Run(*expr.get_argument_value(0), - Arguments{}.expect(type.get()->get_parameter_proxy( + Args{}.expect(type.get()->get_parameter_proxy( chosen_variant_option.value()))); } else { // TODO: error, if there is more then one possible variant in // answer @@ -774,32 +767,32 @@ Result CheckTask::operator()(const nodes::Constructor &expr, for (size_t i = 0; i < type.get()->parameters_size(); ++i) { possible_options.push_back(type.get()->get_parameter_proxy(i)); } - Run(*expr.get_argument_value(0), Arguments{}.expect(possible_options)); + Run(*expr.get_argument_value(0), Args{}.expect(possible_options)); } break; case builtin::Type::OPTIONAL: // first parameter or NULL Run(*expr.get_argument_value(0), - Arguments{}.expect( + Args{}.expect( {type.get()->get_parameter_proxy(0), state().primitive(builtin::Type::NULL_OPTION)})); break; case builtin::Type::RESULT: // first parameter or ERROR[second parameter] Run(*expr.get_argument_value(0), - Arguments{}.expect({type.get()->get_parameter_proxy(0), - state().add_error_of( - type.get()->get_parameter_proxy(1))})); + Args{}.expect({type.get()->get_parameter_proxy(0), + state().add_error_of( + type.get()->get_parameter_proxy(1))})); break; case builtin::Type::ERROR: // first parameter Run(*expr.get_argument_value(0), - Arguments{}.expect(type.get()->get_parameter_proxy(0))); + Args{}.expect(type.get()->get_parameter_proxy(0))); break; case builtin::Type::FUNCTION: case builtin::Type::NONE: // type itself - Run(*expr.get_argument_value(0), Arguments{}.expect(type)); + Run(*expr.get_argument_value(0), Args{}.expect(type)); break; default: // array, basic types type_check_error("Type can't be constructed", expr, executor); @@ -808,14 +801,14 @@ Result CheckTask::operator()(const nodes::Constructor &expr, } // TODO: deduce generic parts in type - return type_check_from_arguments(expr.get_type_proxy(), args, expr, executor); + return type_check_from_args(expr.get_type_proxy(), args, expr, executor); // TODO: add <- modifiier to type ?? } // IN PROGRESS // TODO Result CheckTask::operator()(const nodes::Lambda &expr, - const Arguments &args) { + const Args &args) { if (args.get_expected().empty()) { type_check_error("Can't deduce type of lambda function from context: no " "one type expected", @@ -836,15 +829,15 @@ Result CheckTask::operator()(const nodes::Lambda &expr, } // TODO: deal with return type (+1 sometimes), etc - const auto arguments_given = expr.arguments_size(); - const auto arguments_defined = expected_type.get()->parameters_size(); - if (arguments_given != arguments_defined) { + const auto args_given = expr.args_size(); + const auto args_defined = expected_type.get()->parameters_size(); + if (args_given != args_defined) { type_check_error( "Number of function arguments is different from expected (" + - std::to_string(arguments_given) + " instead of " + - std::to_string(arguments_defined) + - std::string{arguments_defined > 0 - ? (" or " + std::to_string(arguments_defined - 1)) + std::to_string(args_given) + " instead of " + + std::to_string(args_defined) + + std::string{args_defined > 0 + ? (" or " + std::to_string(args_defined - 1)) : ""} + ")", expr, executor); @@ -852,7 +845,7 @@ Result CheckTask::operator()(const nodes::Lambda &expr, // TODO: set another context (for expression typecheck and vars) - for (size_t i = 0; i < arguments_given; ++i) { + for (size_t i = 0; i < args_given; ++i) { if (!state().insert_variable( *expr.get_argument(i)->get(), expected_type.get()->get_parameter_proxy(i), @@ -864,24 +857,23 @@ Result CheckTask::operator()(const nodes::Lambda &expr, } // TODO: out type is can be not last - if (arguments_given + 1 == arguments_defined) { + if (args_given + 1 == args_defined) { Run(*expr.get_expression(), - Arguments{}.expect( - expected_type.get()->get_parameter_proxy(arguments_defined - 1))); + Args{}.expect( + expected_type.get()->get_parameter_proxy(args_defined - 1))); } // TODO: needed ?? (only passed type check required ??) - return type_check_from_arguments(expected_type, args, expr, executor); + return type_check_from_args(expected_type, args, expr, executor); } // IN PROGRESS -Result CheckTask::operator()(const nodes::Extra &, - const Arguments &) { +Result CheckTask::operator()(const nodes::Extra &, const Args &) { return Result(state().primitive(builtin::Type::UNIT)); } Result CheckTask::operator()(const nodes::EmptyLines &, - const Arguments &) { + const Args &) { return Result(state().primitive(builtin::Type::UNIT)); } diff --git a/lang/type_check/src/type_check_utils.cpp b/lang/type_check/src/type_check_utils.cpp index 173cc39..e3a480e 100644 --- a/lang/type_check/src/type_check_utils.cpp +++ b/lang/type_check/src/type_check_utils.cpp @@ -6,30 +6,30 @@ namespace type_check { // pass type -> compare types, return bool // no pass type -> return type -nodes::Type check_same_to_pass_type_in_arguments( - nodes::Type type, const Arguments &arguments, const nodes::Node & /*node*/, - Executor &executor, const std::string &message, bool handle_errors) { +nodes::Type check_same_to_pass_type_in_args(nodes::Type type, const Args &args, + const nodes::Node & /*node*/, + Executor &executor, + const std::string &message, + bool handle_errors) { Log::Context logc(executor.log(), utils::Log::Area::kTypeCheck); - if (not arguments.get_passed().has_value()) { + if (not args.get_passed().has_value()) { return type; } - if (type != arguments.get_passed().value() and handle_errors) { + if (type != args.get_passed().value() and handle_errors) { logc.Error({{message}} /* TODO: node */); } return executor.state().primitive(builtin::Type::BOOL); } -bool check_no_pass_type_in_arguments(const Arguments &arguments, - const nodes::Node &node, - Executor &executor, - const std::string &message, - bool handle_errors) { +bool check_no_pass_type_in_args(const Args &args, const nodes::Node &node, + Executor &executor, const std::string &message, + bool handle_errors) { Log::Context logc(executor.log(), utils::Log::Area::kTypeCheck); - if (arguments.get_passed().has_value()) { + if (args.get_passed().has_value()) { type_check_error(message, node, executor, handle_errors); return false; } @@ -37,12 +37,12 @@ bool check_no_pass_type_in_arguments(const Arguments &arguments, return true; } -Result type_same_to_expected(nodes::Type type, const Arguments &arguments, +Result type_same_to_expected(nodes::Type type, const Args &args, const nodes::Node & /*node*/, Executor &executor, const std::string &message, bool handle_errors) { Log::Context logc(executor.log(), utils::Log::Area::kTypeCheck); - const auto &expected = arguments.get_expected(); + const auto &expected = args.get_expected(); if (expected.empty()) { return Result{type}; @@ -60,10 +60,9 @@ Result type_same_to_expected(nodes::Type type, const Arguments &arguments, return Result{expected.front()}; // any can be choosen } -Result type_check_from_arguments(nodes::Type /*type*/, - const Arguments & /*arguments*/, - const nodes::Node & /*node*/, - Executor &executor, bool /*handle_errors*/) { +Result type_check_from_args(nodes::Type /*type*/, const Args & /*args*/, + const nodes::Node & /*node*/, Executor &executor, + bool /*handle_errors*/) { Log::Context logc(executor.log(), utils::Log::Area::kTypeCheck); /* TODO FIXME */ @@ -140,7 +139,7 @@ std::optional unfold_user_defined_type(nodes::Type type, return std::nullopt; } - // TODO: perform type arguments substitution + // TODO: perform type args substitution logc.Require(type.get()->parameters_size() == 0, {{"Unfold of generic type is not supported (yet)"}}); //