From a11ddbd25fe5db2997f30eef4bf1cb0b40a3a314 Mon Sep 17 00:00:00 2001 From: ProgramSnail Date: Fri, 5 May 2023 10:17:10 +0300 Subject: [PATCH] functions arguments and parameters are separated now --- include/build_visitor.hpp | 2 -- include/interpreter_tree.hpp | 9 ++--- include/visitor.hpp | 2 -- lang-parser | 2 +- src/build_visitor.cpp | 35 ++++++++---------- src/print_visitor.cpp | 7 ++++ src/type_check_visitor.cpp | 69 +++++++++++------------------------- src/visitor.cpp | 21 +++-------- 8 files changed, 49 insertions(+), 98 deletions(-) diff --git a/include/build_visitor.hpp b/include/build_visitor.hpp index 1c85211..3902624 100644 --- a/include/build_visitor.hpp +++ b/include/build_visitor.hpp @@ -90,8 +90,6 @@ private: void Visit(FunctionCallExpression* node) override; - void Visit(FunctionArgument& node) override; // variant - void Visit(TupleExpression* node) override; void Visit(VariantExpression* node) override; void Visit(ReturnExpression* node) override; diff --git a/include/interpreter_tree.hpp b/include/interpreter_tree.hpp index 74041a2..52aa78a 100644 --- a/include/interpreter_tree.hpp +++ b/include/interpreter_tree.hpp @@ -232,12 +232,6 @@ struct ParametrizedTypeclass; struct ParametrizedType; -// - -using FunctionArgument = std::variant< - SubExpressionToken, - std::unique_ptr>; - // Comments [IGNORE] ----------------- // Identifiers, constants, etc. ----------------- @@ -468,7 +462,8 @@ struct FunctionCallExpression { std::optional, std::unique_ptr>> prefix; ExtendedName name; - std::vector arguments; + std::vector> parameters; + std::vector arguments; }; struct TupleExpression { diff --git a/include/visitor.hpp b/include/visitor.hpp index ebb3241..f4fed98 100644 --- a/include/visitor.hpp +++ b/include/visitor.hpp @@ -87,8 +87,6 @@ protected: virtual void Visit(FunctionCallExpression* node); - virtual void Visit(FunctionArgument& node); // variant - virtual void Visit(TupleExpression* node); virtual void Visit(VariantExpression* node); virtual void Visit(ReturnExpression* node); diff --git a/lang-parser b/lang-parser index 1875ec1..910d1b4 160000 --- a/lang-parser +++ b/lang-parser @@ -1 +1 @@ -Subproject commit 1875ec1f091eaa96d62cc5ceee4c0adc7bb6d4a9 +Subproject commit 910d1b4d312002a769869064e83250513257b63e diff --git a/src/build_visitor.cpp b/src/build_visitor.cpp index 4c8e4af..836e439 100644 --- a/src/build_visitor.cpp +++ b/src/build_visitor.cpp @@ -905,26 +905,6 @@ void BuildVisitor::Visit(AccessExpression* node) { // Other expressions -void BuildVisitor::Visit(FunctionArgument& node) { - auto parse_node = current_node_; - - current_node_ = parse_node.NthNamedChild(0); - - std::string current_node_type = current_node_.GetType(); - - if (current_node_type == parser::tokens::SubExpressionToken) { - node = SubExpressionToken(); - Visit(std::get(node)); - } else if (current_node_type == parser::tokens::TypeExpression) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else { - // error - } - - current_node_ = parse_node; -} - void BuildVisitor::Visit(FunctionCallExpression* node) { auto parse_node = current_node_; @@ -953,11 +933,24 @@ void BuildVisitor::Visit(FunctionCallExpression* node) { size_t child_count = parse_node.NamedChildCount(); if (child_count > excluded_child_count) { // always true (repeat1) + bool parameters_ended = false; + node->arguments.resize(child_count - excluded_child_count); for (size_t i = 0; i + excluded_child_count < child_count; ++i) { current_node_ = parse_node.NthNamedChild(i + excluded_child_count); - Visit(node->arguments[i]); + + if (current_node_.GetType() != parser::tokens::TypeExpression) { + parameters_ended = true; + } + + if (!parameters_ended) { + node->parameters.push_back(std::make_unique()); + Visit(node->parameters.back().get()); + } else { + node->arguments.emplace_back(); + Visit(node->arguments.back()); + } } } diff --git a/src/print_visitor.cpp b/src/print_visitor.cpp index a3367f9..7b6da0e 100644 --- a/src/print_visitor.cpp +++ b/src/print_visitor.cpp @@ -438,6 +438,13 @@ void PrintVisitor::Visit(FunctionCallExpression* node) { Visit(&node->name); out_ << "] ("; + + for (auto& parameter : node->parameters) { + Visit(parameter.get()); + out_ << ", "; + } + + out_ << ") ("; for (auto& argument : node->arguments) { Visitor::Visit(argument); out_ << ", "; diff --git a/src/type_check_visitor.cpp b/src/type_check_visitor.cpp index 43f173d..4aa49a9 100644 --- a/src/type_check_visitor.cpp +++ b/src/type_check_visitor.cpp @@ -539,60 +539,31 @@ void TypeCheckVisitor::Visit(FunctionCallExpression* node) { } info::definition::FunctionDeclaration function_declaration = maybe_function_declaration.value(); - // TODO: ?? - // // Visitor::Visit(function_declaration.node->type.get()); - // // - // // std::optional maybe_type_value = context_manager_.GetType(current_type_); - // // if (!maybe_type_value.has_value()) { - // // error_handling::HandleInternalError("Type of function is not FunctionType", "TypeCheckVisitor.FunctionCallExpresssion"); - // // } - // // - // // info::type::FunctionType* type_value = maybe_type_value.value(); + // + + if (function_declaration.parameters.size() != node->parameters.size()) { + error_handling::HandleTypecheckError("Mismatched parameter count in function call expression"); + } + for (size_t i = 0; i < node->parameters.size(); ++i) { + Visit(node->parameters[i].get()); + + std::string parameter_name = function_declaration.parameters[i].type; + + if (context.count(parameter_name) != 0) { + error_handling::HandleInternalError("Local abstract types with same name in one context", "TypeCheckVisitor.FunctionCallExpresssion"); // TypecheckError ?? + } + context[parameter_name] = current_type_; + } // - size_t argument_num = 0; - size_t paramater_num = 0; - - // TODO: parameters and arguments should be separated, parameters go first + if (function_declaration.argument_types.size() + 1 != node->arguments.size()) { + error_handling::HandleTypecheckError("Mismatched argument count in function call expression"); + } for (size_t i = 0; i < node->arguments.size(); ++i) { Visitor::Visit(node->arguments[i]); - if (std::holds_alternative>(node->arguments[i])) { - if (function_declaration.parameters.size() <= paramater_num) { - error_handling::HandleTypecheckError("Mismatched parameter count in function call expression"); - } - - std::string parameter_name = function_declaration.parameters[paramater_num].type; - - if (context.count(parameter_name) != 0) { - error_handling::HandleInternalError("Local abstract types with same name in one context", "TypeCheckVisitor.FunctionCallExpresssion"); // TypecheckError ?? - } - - context[parameter_name] = current_type_; - - ++paramater_num; - } else if (std::holds_alternative(node->arguments[i])) { - if (function_declaration.argument_types.size() <= argument_num) { - error_handling::HandleTypecheckError("Mismatched argument count in function call expression"); - } - - // TODO: not full context, if arguments and parameters not sepoarated - - Visitor::Visit(*function_declaration.argument_types[argument_num]); - context_manager_.AddTypeRequirement(current_type_, TypeInContext(current_type_, context)); - - ++argument_num; - } else { - // error - } - } - - if (function_declaration.parameters.size() != paramater_num) { - error_handling::HandleTypecheckError("Mismatched parameter count in function call expression"); - } - - if (function_declaration.argument_types.size() + 1 != argument_num) { - error_handling::HandleTypecheckError("Mismatched argument count in function call expression"); + Visitor::Visit(*function_declaration.argument_types[i]); + context_manager_.AddTypeRequirement(current_type_, TypeInContext(current_type_, context)); } Visitor::Visit(*function_declaration.argument_types.back()); // add return type to info ?? diff --git a/src/visitor.cpp b/src/visitor.cpp index f5afc4f..a188895 100644 --- a/src/visitor.cpp +++ b/src/visitor.cpp @@ -248,22 +248,6 @@ void Visitor::Visit(SuperExpression& node) { } } -// Simple Expressions - -void Visitor::Visit(FunctionArgument& node) { - switch (node.index()) { - case 0: - Visit(std::get(node)); - break; - case 1: - Visit(std::get>(node).get()); - break; - default: - // error - break; - } -} - // Name void Visitor::Visit(AnyName& node) { @@ -548,6 +532,11 @@ void Visitor::Visit(FunctionCallExpression* node) { } Visit(&node->name); + + for (auto& parameter : node->parameters) { + Visit(parameter.get()); + } + for (auto& argument : node->arguments) { Visit(argument); }