From 64653e6a6a96644f95222e51ff24b420f034e981 Mon Sep 17 00:00:00 2001 From: ProgramSnail Date: Sun, 9 Apr 2023 18:49:52 +0300 Subject: [PATCH] grammar refactoring: part of build_visitor fixed --- include/build_visitor.hpp | 65 +++-- include/interpreter_tree.hpp | 9 +- include/print_visitor.hpp | 2 + include/visitor.hpp | 2 + src/build_visitor.cpp | 549 ++++++++++++----------------------- src/print_visitor.cpp | 22 +- 6 files changed, 245 insertions(+), 404 deletions(-) diff --git a/include/build_visitor.hpp b/include/build_visitor.hpp index a148da2..71e7d09 100644 --- a/include/build_visitor.hpp +++ b/include/build_visitor.hpp @@ -16,8 +16,6 @@ public: } private: - // // void Visit(Node* node) override; - // Sources ----------------- void Visit(SourceFile* node) override; @@ -31,28 +29,21 @@ private: // Definitions ----------------- void Visit(ImportStatement* node) override; - void Visit(UsageDefinition* node) override; - void Visit(AliasDefinition* node) override; - void Visit(VariableDefinition* node) override; + void Visit(AliasDefinitionStatement* node) override; + void Visit(VariableDefinitionStatement* node) override; void Visit(FunctionDeclaration* node) override; - void Visit(FunctionDefinition* node) override; - void Visit(AliasTypeDefinition* node) override; - void Visit(TypeDefinition* node) override; - void Visit(TypeclassDefinition* node) override; + void Visit(FunctionDefinitionStatement* node) override; + void Visit(TypeDefinitionStatement* node) override; + void Visit(AbstractTypeDefinitionStatement* node) override; + void Visit(TypeclassDefinitionStatement* node) override; void Visit(SourceStatement& node) override; // variant - void Visit(ImportSymbol& node) override; // variant // Definition parts - void Visit(DefinedName* node) override; - void Visit(DefinedAnnotatedName* node) override; - void Visit(DefinedType* node) override; - void Visit(DefinedTypeclass* node) override; + void Visit(FunctionDefinition* node) override; + void Visit(TypeDefinition* node) override; void Visit(DefinitionParameter* node) override; - void Visit(DefinitionArgument* node) override; - - void Visit(FunctionDeclarationType& node) override; // variant // Flow control ----------------- @@ -68,10 +59,9 @@ private: // Statements, expressions, blocks, etc. ----------------- - void Visit(Block* node) override; - void Visit(ScopedStatement* node) override; + void Visit(BlockStatement& node) override; // variant - void Visit(LoopControlExpression& node) override; // enum + void Visit(Block* node) override; void Visit(SubExpressionToken& node) override; // variant void Visit(SubExpression& node) override; // variant @@ -79,29 +69,31 @@ private: void Visit(Expression& node) override; // variant void Visit(SuperExpression& node) override; // variant - void Visit(BlockStatement& node) override; // variant + void Visit(ScopedStatement* node) override; // Operators void Visit(BinaryOperatorExpression* node) override; void Visit(UnaryOperatorExpression* node) override; + void Visit(ReferenceExpression* node) override; // Simple Expressions void Visit(FunctionCallExpression* node) override; - void Visit(TupleExpression* node) override; - void Visit(VariantExpression* node) override; - void Visit(ReturnExpression* node) override; void Visit(FunctionArgument& node) override; // variant - // Lambda - + void Visit(TupleExpression* node) override; + void Visit(VariantExpression* node) override; + void Visit(ReturnExpression* node) override; + void Visit(TypeConstructor* node) override; void Visit(LambdaFunction* node) override; + void Visit(ArrayExpression* node) override; + + void Visit(LoopControlExpression& node) override; // enum // Name - void Visit(NameSuperExpression* node) override; void Visit(NameExpression* node) override; void Visit(TupleName* node) override; void Visit(VariantName* node) override; @@ -109,9 +101,11 @@ private: void Visit(AnyName& node) override; // variant + // Type, typeclass, etc. ----------------- + // Type - void Visit(TypeConstructor* node) override; + void Visit(FunctionType* node) override; void Visit(TupleType* node) override; void Visit(VariantType* node) override; void Visit(AnnotatedType* node) override; @@ -119,18 +113,25 @@ private: void Visit(TypeExpression* node) override; void Visit(AnyType& node) override; // variant - void Visit(TypeSubExpression& node) override; // variant - void Visit(TypeParameter& node) override; // variant + void Visit(ExtendedScopedAnyType* node) override; // Typeclass - void Visit(AnnotatedTypeclass* node) override; void Visit(ParametrizedTypeclass* node) override; void Visit(TypeclassExpression* node) override; + void Visit(TypeclassUsage& node) override; // variant + + // Typeclass & Type + + void Visit(TypeParameter& node) override; // variant + void Visit(TypeSubExpression& node) override; // variant + // Identifiers, constants, etc. ----------------- + void Visit(ExtendedName* node) override; + void Visit(AnyIdentifier* node) override; // std::string void Visit(FloatNumberLiteral* node) override; @@ -140,7 +141,7 @@ private: void Visit(Literal& node) override; // variant - void Visit(NameSubSuperExpression& node) override; // variant + void Visit(NameSubExpression& node) override; // variant private: const parser::ParseTree& parse_tree_; parser::ParseTree::Node current_node_; diff --git a/include/interpreter_tree.hpp b/include/interpreter_tree.hpp index b061dae..991a282 100644 --- a/include/interpreter_tree.hpp +++ b/include/interpreter_tree.hpp @@ -215,7 +215,9 @@ using TypeSubExpression = std::variant< // Comments [IGNORE] ----------------- // Identifiers, constants, etc. ----------------- -using ExtendedName = std::string; +struct ExtendedName { + std::string name; +}; struct FloatNumberLiteral; struct NumberLiteral; @@ -255,7 +257,8 @@ struct Sources { // ----------------- Namespaces, partittions ----------------- struct Namespace { - enum { Const, Var } modifier; + enum Modifier { Const, Var }; + std::optional modifier; std::optional name; TypeIdentifier type; std::unique_ptr scope; @@ -315,7 +318,7 @@ struct TypeDefinitionStatement { struct AbstractTypeDefinitionStatement { enum { Basic, Abstract } modifier; - std::unique_ptr definition; + std::unique_ptr type; }; struct TypeclassDefinitionStatement { diff --git a/include/print_visitor.hpp b/include/print_visitor.hpp index d05623a..e34b984 100644 --- a/include/print_visitor.hpp +++ b/include/print_visitor.hpp @@ -101,6 +101,8 @@ private: // Identifiers, constants, etc. ----------------- + void Visit(ExtendedName* node) override; + void Visit(AnyIdentifier* node) override; // std::string void Visit(FloatNumberLiteral* node) override; diff --git a/include/visitor.hpp b/include/visitor.hpp index 9583e77..8a80be4 100644 --- a/include/visitor.hpp +++ b/include/visitor.hpp @@ -128,6 +128,8 @@ protected: // Identifiers, constants, etc. ----------------- + virtual void Visit(ExtendedName* node) {} + virtual void Visit(AnyIdentifier* node) {} // std::string virtual void Visit(FloatNumberLiteral* node) {} diff --git a/src/build_visitor.cpp b/src/build_visitor.cpp index 4cad466..33cd4f7 100644 --- a/src/build_visitor.cpp +++ b/src/build_visitor.cpp @@ -1,6 +1,7 @@ #include #include +#include // for clangd #include "../include/build_visitor.hpp" @@ -47,25 +48,28 @@ void BuildVisitor::Visit(Sources* node) { // Namespaces, partitions ----------------- -void BuildVisitor::Visit(Partition* node) { +void BuildVisitor::Visit(Namespace* node) { auto parse_node = current_node_; - std::string name = parse_node.ChildByFieldName("name").GetValue(); + size_t child_count = parse_node.NamedChildCount(); - if (name == "TEST") { - node->type = Partition::Test; - } else if (name == "INTERFACE") { - node->type = Partition::Interface; - } else if (name == "CORE") { - node->type = Partition::Core; - } else if (name == "LIB") { - node->type = Partition::Lib; - } else if (name == "MODULE") { - node->type = Partition::Module; - } else if (name == "EXE") { - node->type = Partition::Exe; + if (child_count > 2) { + current_node_ = parse_node.ChildByFieldName("name"); + + std::string modifier = parse_node.NthChild(1).GetValue(); + if (modifier == "const") { + node->modifier = Namespace::Const; + } else if (modifier == "var") { + node->modifier = Namespace::Var; + } + + node->name = ExtendedName(); + Visit(&node->name.value()); } + current_node_ = parse_node.ChildByFieldName("type"); + Visit(&node->type); + current_node_ = parse_node.ChildByFieldName("scope"); node->scope = std::make_unique(); Visit(node->scope.get()); @@ -73,28 +77,23 @@ void BuildVisitor::Visit(Partition* node) { current_node_ = parse_node; } -void BuildVisitor::Visit(Namespace* node) { +void BuildVisitor::Visit(Partition* node) { auto parse_node = current_node_; - current_node_ = parse_node.ChildByFieldName("name"); + std::string name = parse_node.ChildByFieldName("name").GetValue(); - auto current_node_type = current_node_.GetType(); - - if (current_node_type == parser::tokens::DefinedAnnotatedName) { - std::string name_modifier = parse_node.NthChild(1).GetValue(); // TODO - if (name_modifier == "const") { - node->is_const = true; - } else if (name_modifier == "var") { - node->is_const = false; - } - - node->name = std::make_unique(); - Visit(std::get>(node->name).get()); - } else if (current_node_type == parser::tokens::DefinedType) { - node->is_const = false; // TODO - - node->name = std::make_unique(); - Visit(std::get>(node->name).get()); + if (name == "TEST") { + node->name = Partition::Test; + } else if (name == "INTERFACE") { + node->name = Partition::Interface; + } else if (name == "CORE") { + node->name = Partition::Core; + } else if (name == "LIB") { + node->name = Partition::Lib; + } else if (name == "MODULE") { + node->name = Partition::Module; + } else if (name == "EXE") { + node->name = Partition::Exe; } current_node_ = parse_node.ChildByFieldName("scope"); @@ -109,41 +108,54 @@ void BuildVisitor::Visit(Namespace* node) { void BuildVisitor::Visit(ImportStatement* node) { auto parse_node = current_node_; + size_t excluded_child_count = 0; + + if (parse_node.NthChild(0).GetValue() == "use") { + node->name = parse_node.ChildByFieldName("name").GetValue(); + ++excluded_child_count; + } + auto module_name_node = parse_node.ChildByFieldName("module_name"); - node->module_name = module_name_node.NthChild(1).GetValue(); // open string literal + node->module_name = module_name_node.NthChild(1).GetValue(); + ++excluded_child_count; size_t child_count = parse_node.NamedChildCount(); - if (child_count > 1) { - node->symbols.resize(child_count - 1); + if (child_count > excluded_child_count) { + node->symbols.resize(child_count - excluded_child_count); - for (size_t i = 0; i < child_count - 1; ++i) { - current_node_ = parse_node.NthNamedChild(i + 1); - Visit(node->symbols[i]); + for (size_t i = 0; i < child_count - excluded_child_count; ++i) { + current_node_ = parse_node.NthNamedChild(i + excluded_child_count); + Visit(&node->symbols[i]); } } current_node_ = parse_node; } -void BuildVisitor::Visit(UsageDefinition* node) { +void BuildVisitor::Visit(AliasDefinitionStatement* node) { auto parse_node = current_node_; - node->name = parse_node.ChildByFieldName("name").GetValue(); + std::string modifier = parse_node.NthChild(0).GetValue(); + if (modifier == "alias") { + node->modifier = AliasDefinitionStatement::Alias; + } else if (modifier == "type") { + node->modifier = AliasDefinitionStatement::Type; + } else if (modifier == "let") { + node->modifier = AliasDefinitionStatement::Let; + } - current_node_ = parse_node.ChildByFieldName("import_statement"); - node->import_statement = std::make_unique(); - Visit(node->import_statement.get()); + node->type = parse_node.ChildByFieldName("type").GetValue(); - current_node_ = parse_node; -} + size_t child_count = parse_node.NamedChildCount(); -void BuildVisitor::Visit(AliasDefinition* node) { - auto parse_node = current_node_; + if (child_count > 2) { + node->parameters.resize(child_count - 2); - current_node_ = parse_node.ChildByFieldName("type"); - node->type = std::make_unique(); - Visit(node->type.get()); + for (size_t i = 0; i + 2 < child_count; ++i) { + node->parameters[i] = parse_node.NthNamedChild(i + 1).GetValue(); + } + } current_node_ = parse_node.ChildByFieldName("value"); node->value = std::make_unique(); @@ -152,17 +164,18 @@ void BuildVisitor::Visit(AliasDefinition* node) { current_node_ = parse_node; } -void BuildVisitor::Visit(VariableDefinition* node) { +void BuildVisitor::Visit(VariableDefinitionStatement* node) { auto parse_node = current_node_; - std::string name_modifier = parse_node.NthChild(0).GetValue(); - if (name_modifier == "const") { - node->is_const = true; - } else if (name_modifier == "var") { - node->is_const = false; + std::string modifier = parse_node.NthChild(0).GetValue(); + if (modifier == "const") { + node->modifier = VariableDefinitionStatement::Const; + } else if (modifier == "var") { + node->modifier = VariableDefinitionStatement::Var; } - node->name = parse_node.ChildByFieldName("name").GetValue(); + current_node_ = parse_node.ChildByFieldName("name"); + Visit(node->name); current_node_ = parse_node.ChildByFieldName("value"); Visit(node->value); @@ -177,35 +190,24 @@ void BuildVisitor::Visit(FunctionDeclaration* node) { size_t child_count = parse_node.NamedChildCount(); - if (child_count > 1) { - bool parameters_ended = false; - - for (size_t i = 0; i < child_count - 1; ++i) { - current_node_ = parse_node.NthNamedChild(i + 1); - - if (current_node_.GetType() != parser::tokens::DefinitionParameter) { - parameters_ended = true; - } - - if (!parameters_ended) { - node->parameters.push_back(std::make_unique()); - Visit(node->parameters.back().get()); - } else { - node->argument_types.emplace_back(); - Visit(node->argument_types.back()); - } - } + for (size_t i = 0; i + 2 < child_count; ++i) { + current_node_ = parse_node.NthNamedChild(i + 1); + node->parameters.push_back(std::make_unique()); + Visit(node->parameters.back().get()); } + current_node_ = parse_node.ChildByFieldName("type"); + Visit(node->type.get()); + current_node_ = parse_node; } -void BuildVisitor::Visit(FunctionDefinition* node) { +void BuildVisitor::Visit(FunctionDefinitionStatement* node) { auto parse_node = current_node_; - current_node_ = parse_node.ChildByFieldName("name"); - node->name = std::make_unique(); - Visit(node->name.get()); + current_node_ = parse_node.ChildByFieldName("definition"); + node->definition = std::make_unique(); + Visit(node->definition.get()); current_node_ = parse_node.ChildByFieldName("value"); Visit(node->value); @@ -213,33 +215,19 @@ void BuildVisitor::Visit(FunctionDefinition* node) { current_node_ = parse_node; } -void BuildVisitor::Visit(AliasTypeDefinition* node) { +void BuildVisitor::Visit(TypeDefinitionStatement* node) { auto parse_node = current_node_; - current_node_ = parse_node.ChildByFieldName("type"); - node->type = std::make_unique(); - Visit(node->type.get()); - - current_node_ = parse_node.ChildByFieldName("value"); - node->value = std::make_unique(); - Visit(node->value.get()); - - current_node_ = parse_node; -} - -void BuildVisitor::Visit(TypeDefinition* node) { - auto parse_node = current_node_; - - std::string type_modifier = parse_node.NthChild(0).GetValue(); // TODO - if (type_modifier == "class") { - node->is_class = true; - } else if (type_modifier == "struct") { - node->is_class = false; + std::string modifier = parse_node.NthChild(0).GetValue(); + if (modifier == "class") { + node->modifier = TypeDefinitionStatement::Class; + } else if (modifier == "struct") { + node->modifier = TypeDefinitionStatement::Struct; } - current_node_ = parse_node.ChildByFieldName("type"); - node->type = std::make_unique(); - Visit(node->type.get()); + current_node_ = parse_node.ChildByFieldName("definition"); + node->definition = std::make_unique(); + Visit(node->definition.get()); current_node_ = parse_node.ChildByFieldName("value"); Visit(node->value); @@ -247,19 +235,36 @@ void BuildVisitor::Visit(TypeDefinition* node) { current_node_ = parse_node; } -void BuildVisitor::Visit(TypeclassDefinition* node) { +void BuildVisitor::Visit(AbstractTypeDefinitionStatement* node) { auto parse_node = current_node_; - current_node_ = parse_node.ChildByFieldName("typeclass"); - node->typeclass = std::make_unique(); - Visit(node->typeclass.get()); + std::string modifier = parse_node.NthChild(0).GetValue(); + if (modifier == "basic") { + node->modifier = AbstractTypeDefinitionStatement::Basic; + } else if (modifier == "abstract") { + node->modifier = AbstractTypeDefinitionStatement::Abstract; + } + + current_node_ = parse_node.ChildByFieldName("type"); + node->type = std::make_unique(); + Visit(node->type.get()); + + current_node_ = parse_node; +} + +void BuildVisitor::Visit(TypeclassDefinitionStatement* node) { + auto parse_node = current_node_; + + current_node_ = parse_node.ChildByFieldName("definition"); + node->definition = std::make_unique(); + Visit(node->definition.get()); size_t child_count = parse_node.NamedChildCount(); if (child_count > 1) { node->requirements.resize(child_count - 1); - for (size_t i = 0; i < child_count - 1; ++i) { + for (size_t i = 0; i + 1 < child_count; ++i) { current_node_ = parse_node.NthNamedChild(i + 1); node->requirements[i] = std::make_unique(); Visit(node->requirements[i].get()); @@ -281,30 +286,24 @@ void BuildVisitor::Visit(SourceStatement& node) { if (current_node_type == parser::tokens::ImportStatement) { // optimize ?? node = std::make_unique(); Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::UsageDefinition) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::AliasDefinition) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::VariableDefinition) { - node = std::make_unique(); - Visit(std::get>(node).get()); + } else if (current_node_type == parser::tokens::AliasDefinitionStatement) { + node = std::make_unique(); + Visit(std::get>(node).get()); } else if (current_node_type == parser::tokens::FunctionDeclaration) { node = std::make_unique(); Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::FunctionDefinition) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::AliasTypeDefinition) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::TypeDefinition) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::TypeclassDefinition) { - node = std::make_unique(); - Visit(std::get>(node).get()); + } else if (current_node_type == parser::tokens::FunctionDefinitionStatement) { + node = std::make_unique(); + Visit(std::get>(node).get()); + } else if (current_node_type == parser::tokens::TypeDefinitionStatement) { + node = std::make_unique(); + Visit(std::get>(node).get()); + } else if (current_node_type == parser::tokens::AbstractTypeDefinitionStatement) { + node = std::make_unique(); + Visit(std::get>(node).get()); + } else if (current_node_type == parser::tokens::TypeclassDefinitionStatement) { + node = std::make_unique(); + Visit(std::get>(node).get()); } else if (current_node_type == parser::tokens::Namespace) { node = std::make_unique(); Visit(std::get>(node).get()); @@ -315,44 +314,25 @@ void BuildVisitor::Visit(SourceStatement& node) { current_node_ = parse_node; } -void BuildVisitor::Visit(ImportSymbol& 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::TypeclassExpression) { // optimize ?? - node = std::make_unique(); - Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::TypeExpression) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::NameExpression) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else { - // error - } - - current_node_ = parse_node; -} - // Definition parts -void BuildVisitor::Visit(DefinedName* node) { +void BuildVisitor::Visit(FunctionDefinition* node) { auto parse_node = current_node_; - node->name = parse_node.ChildByFieldName("name").GetValue(); + node->name = parse_node.ChildByFieldName("name").GetValue(); // TODO: check on operator - node->is_operator = (parse_node.NthChild(0).GetValue() == "("); // TODO + if (parse_node.NthChild(0).GetValue() == "(") { + node->modifier = FunctionDefinition::Operator; + } else { + node->modifier = FunctionDefinition::Function; + } size_t child_count = parse_node.NamedChildCount(); if (child_count > 1) { bool parameters_ended = false; - for (size_t i = 0; i < child_count - 1; ++i) { + for (size_t i = 0; i + 1 < child_count; ++i) { current_node_ = parse_node.NthNamedChild(i + 1); if (current_node_.GetType() != parser::tokens::DefinitionParameter) { @@ -363,8 +343,8 @@ void BuildVisitor::Visit(DefinedName* node) { node->parameters.push_back(std::make_unique()); Visit(node->parameters.back().get()); } else { - node->arguments.push_back(std::make_unique()); - Visit(node->arguments.back().get()); + node->arguments.emplace_back(); + Visit(&node->arguments.back()); } } } @@ -372,30 +352,7 @@ void BuildVisitor::Visit(DefinedName* node) { current_node_ = parse_node; } -void BuildVisitor::Visit(DefinedAnnotatedName* node) { - auto parse_node = current_node_; - - node->name = parse_node.ChildByFieldName("name").GetValue(); - - size_t child_count = parse_node.NamedChildCount(); - - if (child_count > 1) { - current_node_ = parse_node.NthNamedChild(1); - - auto current_node_type = current_node_.GetType(); - if (current_node_type == parser::tokens::DefinedType) { - node->type = std::make_unique(); - Visit(std::get>(node->type).get()); - } else if (current_node_type == parser::tokens::DefinedTypeclass) { - node->type = std::make_unique(); - Visit(std::get>(node->type).get()); - } - - current_node_ = parse_node; - } -} - -void BuildVisitor::Visit(DefinedType* node) { +void BuildVisitor::Visit(TypeDefinition* node) { auto parse_node = current_node_; current_node_ = parse_node.ChildByFieldName("type"); @@ -405,54 +362,10 @@ void BuildVisitor::Visit(DefinedType* node) { size_t child_count = parse_node.NamedChildCount(); if (child_count > 1) { - bool parameters_ended = false; - - for (size_t i = 0; i < child_count - 1; ++i) { + for (size_t i = 0; i + 1 < child_count; ++i) { current_node_ = parse_node.NthNamedChild(i + 1); - - if (current_node_.GetType() != parser::tokens::DefinitionParameter) { - parameters_ended = true; - } - - if (!parameters_ended) { - node->parameters.push_back(std::make_unique()); - Visit(node->parameters.back().get()); - } else { - node->arguments.push_back(std::make_unique()); - Visit(node->arguments.back().get()); - } - } - } - - current_node_ = parse_node; -} - -void BuildVisitor::Visit(DefinedTypeclass* node) { - auto parse_node = current_node_; - - current_node_ = parse_node.ChildByFieldName("typeclass"); - node->typeclass = std::make_unique(); - Visit(node->typeclass.get()); - - size_t child_count = parse_node.NamedChildCount(); - - if (child_count > 1) { - bool parameters_ended = false; - - for (size_t i = 0; i < child_count - 1; ++i) { - current_node_ = parse_node.NthNamedChild(i + 1); - - if (current_node_.GetType() != parser::tokens::DefinitionParameter) { - parameters_ended = true; - } - - if (!parameters_ended) { - node->parameters.push_back(std::make_unique()); - Visit(node->parameters.back().get()); - } else { - node->arguments.push_back(std::make_unique()); - Visit(node->arguments.back().get()); - } + node->parameters.push_back(std::make_unique()); + Visit(node->parameters.back().get()); } } @@ -469,83 +382,16 @@ void BuildVisitor::Visit(DefinitionParameter* node) { if (child_count > 1) { node->typeclasses.resize(child_count - 1); - for (size_t i = 0; i < child_count - 1; ++i) { + for (size_t i = 0; i + 1 < child_count; ++i) { current_node_ = parse_node.NthNamedChild(i + 1); - - std::string current_node_type = current_node_.GetType(); - - node->typeclasses[i] = std::make_unique(); - - if (current_node_type == parser::tokens::TypeclassExpression) { // optimize ?? - node->typeclasses[i]->typeclass_expression = std::make_unique(); - Visit(node->typeclasses[i]->typeclass_expression.get()); - } else if (current_node_type == parser::tokens::ParametrizedTypeclass) { - Visit(node->typeclasses[i].get()); - } else { - // error - } + Visit(node->typeclasses[i]); } } current_node_ = parse_node; } -void BuildVisitor::Visit(DefinitionArgument* node) { - auto parse_node = current_node_; - - node->name = parse_node.ChildByFieldName("name").GetValue(); - - size_t child_count = parse_node.NamedChildCount(); - - if (child_count > 1) { - node->types.resize(child_count - 1); - - for (size_t i = 0; i < child_count - 1; ++i) { - current_node_ = parse_node.NthNamedChild(i + 1); - - std::string current_node_type = current_node_.GetType(); - - node->types[i] = std::make_unique(); - - if (current_node_type == parser::tokens::TypeExpression) { // optimize ?? - node->types[i]->type_expression = std::make_unique(); - Visit(node->types[i]->type_expression.get()); - } else if (current_node_type == parser::tokens::ParametrizedType) { - Visit(node->types[i].get()); - } else { - // error - } - } - } - - current_node_ = parse_node; -} - -void BuildVisitor::Visit(FunctionDeclarationType& 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::ParametrizedType) { // optimize ?? - node = std::make_unique(); - Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::TupleType) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::VariantType) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::ParametrizedTypeclass) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else { - // error - } - - current_node_ = parse_node; -} +// TODO <-- fixes ended there // Flow control ----------------- @@ -558,7 +404,7 @@ void BuildVisitor::Visit(MatchCase* node) { size_t child_count = parse_node.NamedChildCount(); if (child_count > 1) { - std::string prefix = parse_node.NthChild(2).GetValue(); // TODO + std::string prefix = parse_node.NthChild(2).GetValue(); if (child_count > 2 || prefix == "?") { current_node_ = parse_node.ChildByFieldName("condition"); @@ -742,9 +588,9 @@ void BuildVisitor::Visit(SubExpressionToken& node) { std::string current_node_type = current_node_.GetType(); - if (current_node_type == parser::tokens::NameSuperExpression) { // optimize ?? - node = std::make_unique(); - Visit(std::get>(node).get()); + if (current_node_type == parser::tokens::NameExpression) { // optimize ?? + node = std::make_unique(); + Visit(std::get>(node).get()); } else if (current_node_type == parser::tokens::ScopedStatement) { node = std::make_unique(); Visit(std::get>(node).get()); @@ -867,12 +713,9 @@ void BuildVisitor::Visit(BlockStatement& node) { if (current_node_type == parser::tokens::Expression) { // optimize ?? node = std::make_unique(); Visit(*std::get>(node)); - } else if (current_node_type == parser::tokens::AliasDefinition) { - node = std::make_unique(); - Visit(std::get>(node).get()); - } else if (current_node_type == parser::tokens::VariableDefinition) { - node = std::make_unique(); - Visit(std::get>(node).get()); + } else if (current_node_type == parser::tokens::VariableDefinitionStatement) { + node = std::make_unique(); + Visit(std::get>(node).get()); } else if (current_node_type == parser::tokens::FlowControl) { node = std::make_unique(); Visit(*std::get>(node)); @@ -919,7 +762,7 @@ void BuildVisitor::Visit(FunctionCallExpression* node) { auto parse_node = current_node_; current_node_ = parse_node.ChildByFieldName("name"); - node->name = std::make_unique(); + node->name = std::make_unique(); Visit(node->name.get()); size_t child_count = parse_node.NamedChildCount(); @@ -1032,7 +875,7 @@ void BuildVisitor::Visit(LambdaFunction* node) { // Name -void BuildVisitor::Visit(NameSuperExpression* node) { +void BuildVisitor::Visit(NameExpression* node) { auto parse_node = current_node_; size_t child_count = parse_node.NamedChildCount(); @@ -1075,33 +918,6 @@ void BuildVisitor::Visit(NameSuperExpression* node) { current_node_ = parse_node; } -void BuildVisitor::Visit(NameExpression* node) { - auto parse_node = current_node_; - - size_t child_count = parse_node.NamedChildCount(); - - if (child_count > 1) { - bool types_ended = false; - - for (size_t i = 0; i < child_count - 1; ++i) { - current_node_ = parse_node.NthNamedChild(i); - - if (current_node_.GetType() != parser::tokens::TypeSubExpression) { - types_ended = true; - } - - if (!types_ended) { - node->namespaces.emplace_back(); - Visit(node->namespaces.back()); - } else { - node->names.push_back(current_node_.GetValue()); - } - } - } - - current_node_ = parse_node; -} - void BuildVisitor::Visit(TupleName* node) { auto parse_node = current_node_; @@ -1174,27 +990,27 @@ void BuildVisitor::Visit(AnyName& node) { // Type void BuildVisitor::Visit(TypeConstructor* node) { - // auto parse_node = current_node_; - // - // current_node_ = parse_node.ChildByFieldName("type"); - // node->type = std::make_unique(); - // Visit(node->type.get()); - // - // size_t parameter_count = (parse_node.NamedChildCount() - 1) / 2; - // - // node->parameters.resize(parameter_count); - // - // for (size_t i = 0; i < parameter_count * 2; ++i) { - // current_node_ = parse_node.NthNamedChild(i + 1); - // - // if (i % 2 == 0) { - // node->parameters[i / 2].first = current_node_.GetValue(); - // } else { - // Visit(node->parameters[i / 2].second); - // } - // } - // - // current_node_ = parse_node; + auto parse_node = current_node_; + + current_node_ = parse_node.ChildByFieldName("type"); + node->type = std::make_unique(); + Visit(node->type.get()); + + size_t parameter_count = (parse_node.NamedChildCount() - 1) / 2; + + node->parameters.resize(parameter_count); + + for (size_t i = 0; i < parameter_count * 2; ++i) { + current_node_ = parse_node.NthNamedChild(i + 1); + + if (i % 2 == 0) { + node->parameters[i / 2].first = current_node_.GetValue(); + } else { + Visit(node->parameters[i / 2].second); + } + } + + current_node_ = parse_node; } void BuildVisitor::Visit(TupleType* node) { @@ -1204,7 +1020,7 @@ void BuildVisitor::Visit(TupleType* node) { current_node_ = parse_node.NthNamedChild(current_node_n); - if (current_node_.GetType() == parser::tokens::TypeIdentifierDefinition) { + if (current_node_.GetType() == parser::tokens::Constructor) { node->type = current_node_.GetValue(); // TODO check ++current_node_n; @@ -1237,7 +1053,7 @@ void BuildVisitor::Visit(VariantType* node) { current_node_ = parse_node.NthNamedChild(current_node_n); - if (current_node_.GetType() == parser::tokens::TypeIdentifierDefinition) { + if (current_node_.GetType() == parser::tokens::Constructor) { node->type = current_node_.GetValue(); // TODO check ++current_node_n; @@ -1484,9 +1300,18 @@ void BuildVisitor::Visit(TypeclassExpression* node) { // Identifiers, constants, etc. ----------------- +void BuildVisitor::Visit(ExtendedName* node) { // TODO: check + size_t child_count = current_node_.NamedChildCount(); + if (child_count > 1) { + node->name = current_node_.GetValue(); + } else { + node->name = current_node_.NthNamedChild(0).GetValue(); + } +} + void BuildVisitor::Visit(AnyIdentifier* node) { // std::string *node = current_node_.GetValue(); -} // TODO use in other places ?? +} void BuildVisitor::Visit(FloatNumberLiteral* node) { node->value = std::stod(current_node_.GetValue()); diff --git a/src/print_visitor.cpp b/src/print_visitor.cpp index e329f00..02226fd 100644 --- a/src/print_visitor.cpp +++ b/src/print_visitor.cpp @@ -60,13 +60,17 @@ void PrintVisitor::Visit(Partition* node) { void PrintVisitor::Visit(Namespace* node) { out_ << "[Namespace] "; if (node->name.has_value()) { - switch (node->modifier) { - case Namespace::Const: - out_ << "const "; - break; - case Namespace::Var: - out_ << "var "; - break; + if (node->modifier.has_value()) { + switch (node->modifier.value()) { + case Namespace::Const: + out_ << "const "; + break; + case Namespace::Var: + out_ << "var "; + break; + } + } else { + // error } Visit(&node->name.value()); } @@ -647,6 +651,10 @@ void PrintVisitor::Visit(TypeclassExpression* node) { // Identifiers, constants, etc. ----------------- +void PrintVisitor::Visit(ExtendedName* node) { + out_ << "[ExtendedName " << node->name << "] "; +} + void PrintVisitor::Visit(AnyIdentifier* node) { // std::string out_ << "[Identifier " << *node << "] "; }