grammar refactoring: part of build_visitor fixed

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(AliasDefinitionStatement* node) override;
-  void Visit(AliasDefinition* node) override;
+  void Visit(VariableDefinitionStatement* node) override;
-  void Visit(VariableDefinition* node) override;
   void Visit(FunctionDeclaration* node) override;
-  void Visit(FunctionDefinition* node) override;
+  void Visit(FunctionDefinitionStatement* node) override;
-  void Visit(AliasTypeDefinition* node) override;
+  void Visit(TypeDefinitionStatement* node) override;
-  void Visit(TypeDefinition* node) override;
+  void Visit(AbstractTypeDefinitionStatement* node) override;
-  void Visit(TypeclassDefinition* 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(FunctionDefinition* node) override;
-  void Visit(DefinedAnnotatedName* node) override;
+  void Visit(TypeDefinition* node) override;
-  void Visit(DefinedType* node) override;
-  void Visit(DefinedTypeclass* 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(BlockStatement& node) override; // variant
-  void Visit(ScopedStatement* node) override;
 
-  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_;

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> modifier;
   std::optional<ExtendedName> name;
   TypeIdentifier type;
   std::unique_ptr<Sources> scope;
@@ -315,7 +318,7 @@ struct TypeDefinitionStatement {
 
 struct AbstractTypeDefinitionStatement {
   enum { Basic, Abstract } modifier;
-  std::unique_ptr<AnnotatedType> definition;
+  std::unique_ptr<AnnotatedType> type;
 };
 
 struct TypeclassDefinitionStatement {

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;

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) {}

src/build_visitor.cpp

@@ -1,6 +1,7 @@
 #include <iostream>
 
 #include <memory>
+#include <sched.h>
 
 // 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") {
+  if (child_count > 2) {
-      node->type = Partition::Test;
+    current_node_ = parse_node.ChildByFieldName("name");
-  } else if (name == "INTERFACE") {
+
-      node->type = Partition::Interface;
+    std::string modifier = parse_node.NthChild(1).GetValue();
-  } else if (name == "CORE") {
+    if (modifier == "const") {
-      node->type = Partition::Core;
+      node->modifier = Namespace::Const;
-  } else if (name == "LIB") {
+    } else if (modifier == "var") {
-      node->type = Partition::Lib;
+      node->modifier = Namespace::Var;
-  } else if (name == "MODULE") {
+    }
-      node->type = Partition::Module;
+
-  } else if (name == "EXE") {
+    node->name = ExtendedName();
-      node->type = Partition::Exe;
+    Visit(&node->name.value());
   }
 
+  current_node_ = parse_node.ChildByFieldName("type");
+  Visit(&node->type);
+
   current_node_ = parse_node.ChildByFieldName("scope");
   node->scope = std::make_unique<Sources>();
   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 (name == "TEST") {
-
+      node->name = Partition::Test;
-  if (current_node_type == parser::tokens::DefinedAnnotatedName) {
+  } else if (name == "INTERFACE") {
-    std::string name_modifier = parse_node.NthChild(1).GetValue(); // TODO
+      node->name = Partition::Interface;
-    if (name_modifier == "const") {
+  } else if (name == "CORE") {
-      node->is_const = true;
+      node->name = Partition::Core;
-    } else if (name_modifier == "var") {
+  } else if (name == "LIB") {
-      node->is_const = false;
+      node->name = Partition::Lib;
-    }
+  } else if (name == "MODULE") {
-
+      node->name = Partition::Module;
-    node->name = std::make_unique<DefinedAnnotatedName>();
+  } else if (name == "EXE") {
-    Visit(std::get<std::unique_ptr<DefinedAnnotatedName>>(node->name).get());
+      node->name = Partition::Exe;
-  } else if (current_node_type == parser::tokens::DefinedType) {
-    node->is_const = false; // TODO
-
-    node->name = std::make_unique<DefinedType>();
-    Visit(std::get<std::unique_ptr<DefinedType>>(node->name).get());
   }
 
   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) {
+  if (child_count > excluded_child_count) {
-    node->symbols.resize(child_count - 1);
+    node->symbols.resize(child_count - excluded_child_count);
 
-    for (size_t i = 0; i < child_count - 1; ++i) {
+    for (size_t i = 0; i < child_count - excluded_child_count; ++i) {
-        current_node_ = parse_node.NthNamedChild(i + 1);
+        current_node_ = parse_node.NthNamedChild(i + excluded_child_count);
-        Visit(node->symbols[i]);
+        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->type = parse_node.ChildByFieldName("type").GetValue();
-  node->import_statement = std::make_unique<ImportStatement>();
-  Visit(node->import_statement.get());
 
-  current_node_ = parse_node;
+  size_t child_count = parse_node.NamedChildCount();
-}
 
-void BuildVisitor::Visit(AliasDefinition* node) {
+  if (child_count > 2) {
-  auto parse_node = current_node_;
+    node->parameters.resize(child_count - 2);
 
-  current_node_ = parse_node.ChildByFieldName("type");
+    for (size_t i = 0; i + 2 < child_count; ++i) {
-  node->type = std::make_unique<DefinedType>();
+        node->parameters[i] = parse_node.NthNamedChild(i + 1).GetValue();
-  Visit(node->type.get());
+    }
+  }
 
   current_node_ = parse_node.ChildByFieldName("value");
   node->value = std::make_unique<ParametrizedType>();
@@ -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();
+  std::string modifier = parse_node.NthChild(0).GetValue();
-  if (name_modifier == "const") {
+  if (modifier == "const") {
-    node->is_const = true;
+    node->modifier = VariableDefinitionStatement::Const;
-  } else if (name_modifier == "var") {
+  } else if (modifier == "var") {
-    node->is_const = false;
+    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) {
+  for (size_t i = 0; i + 2 < child_count; ++i) {
-    bool parameters_ended = false;
+      current_node_ = parse_node.NthNamedChild(i + 1);
-
+      node->parameters.push_back(std::make_unique<DefinitionParameter>());
-    for (size_t i = 0; i < child_count - 1; ++i) {
+      Visit(node->parameters.back().get());
-        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<DefinitionParameter>());
-          Visit(node->parameters.back().get());
-        } else {
-          node->argument_types.emplace_back();
-          Visit(node->argument_types.back());
-        }
-    }
   }
 
+  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");
+  current_node_ = parse_node.ChildByFieldName("definition");
-  node->name = std::make_unique<DefinedName>();
+  node->definition = std::make_unique<FunctionDefinition>();
-  Visit(node->name.get());
+  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");
+  std::string modifier = parse_node.NthChild(0).GetValue();
-  node->type = std::make_unique<DefinedType>();
+  if (modifier == "class") {
-  Visit(node->type.get());
+    node->modifier = TypeDefinitionStatement::Class;
-
+  } else if (modifier == "struct") {
-  current_node_ = parse_node.ChildByFieldName("value");
+    node->modifier = TypeDefinitionStatement::Struct;
-  node->value = std::make_unique<ParametrizedType>();
-  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;
   }
 
-  current_node_ = parse_node.ChildByFieldName("type");
+  current_node_ = parse_node.ChildByFieldName("definition");
-  node->type = std::make_unique<DefinedType>();
+  node->definition = std::make_unique<TypeDefinition>();
-  Visit(node->type.get());
+  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");
+  std::string modifier = parse_node.NthChild(0).GetValue();
-  node->typeclass = std::make_unique<DefinedTypeclass>();
+  if (modifier == "basic") {
-  Visit(node->typeclass.get());
+    node->modifier = AbstractTypeDefinitionStatement::Basic;
+  } else if (modifier == "abstract") {
+    node->modifier = AbstractTypeDefinitionStatement::Abstract;
+  }
+
+  current_node_ = parse_node.ChildByFieldName("type");
+  node->type = std::make_unique<AnnotatedType>();
+  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<TypeDefinition>();
+  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<FunctionDeclaration>();
         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<ImportStatement>();
     Visit(std::get<std::unique_ptr<ImportStatement>>(node).get());
-  } else if (current_node_type == parser::tokens::UsageDefinition) {
+  } else if (current_node_type == parser::tokens::AliasDefinitionStatement) {
-    node = std::make_unique<UsageDefinition>();
+    node = std::make_unique<AliasDefinitionStatement>();
-    Visit(std::get<std::unique_ptr<UsageDefinition>>(node).get());
+    Visit(std::get<std::unique_ptr<AliasDefinitionStatement>>(node).get());
-  } else if (current_node_type == parser::tokens::AliasDefinition) {
-    node = std::make_unique<AliasDefinition>();
-    Visit(std::get<std::unique_ptr<AliasDefinition>>(node).get());
-  } else if (current_node_type == parser::tokens::VariableDefinition) {
-    node = std::make_unique<VariableDefinition>();
-    Visit(std::get<std::unique_ptr<VariableDefinition>>(node).get());
   } else if (current_node_type == parser::tokens::FunctionDeclaration) {
     node = std::make_unique<FunctionDeclaration>();
     Visit(std::get<std::unique_ptr<FunctionDeclaration>>(node).get());
-  } else if (current_node_type == parser::tokens::FunctionDefinition) {
+  } else if (current_node_type == parser::tokens::FunctionDefinitionStatement) {
-    node = std::make_unique<FunctionDefinition>();
+    node = std::make_unique<FunctionDefinitionStatement>();
-    Visit(std::get<std::unique_ptr<FunctionDefinition>>(node).get());
+    Visit(std::get<std::unique_ptr<FunctionDefinitionStatement>>(node).get());
-  } else if (current_node_type == parser::tokens::AliasTypeDefinition) {
+  } else if (current_node_type == parser::tokens::TypeDefinitionStatement) {
-    node = std::make_unique<AliasTypeDefinition>();
+    node = std::make_unique<TypeDefinitionStatement>();
-    Visit(std::get<std::unique_ptr<AliasTypeDefinition>>(node).get());
+    Visit(std::get<std::unique_ptr<TypeDefinitionStatement>>(node).get());
-  } else if (current_node_type == parser::tokens::TypeDefinition) {
+  } else if (current_node_type == parser::tokens::AbstractTypeDefinitionStatement) {
-    node = std::make_unique<TypeDefinition>();
+    node = std::make_unique<AbstractTypeDefinitionStatement>();
-    Visit(std::get<std::unique_ptr<TypeDefinition>>(node).get());
+    Visit(std::get<std::unique_ptr<AbstractTypeDefinitionStatement>>(node).get());
-  } else if (current_node_type == parser::tokens::TypeclassDefinition) {
+  } else if (current_node_type == parser::tokens::TypeclassDefinitionStatement) {
-    node = std::make_unique<TypeclassDefinition>();
+    node = std::make_unique<TypeclassDefinitionStatement>();
-    Visit(std::get<std::unique_ptr<TypeclassDefinition>>(node).get());
+    Visit(std::get<std::unique_ptr<TypeclassDefinitionStatement>>(node).get());
   } else if (current_node_type == parser::tokens::Namespace) {
     node = std::make_unique<Namespace>();
     Visit(std::get<std::unique_ptr<Namespace>>(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<TypeclassExpression>();
-    Visit(std::get<std::unique_ptr<TypeclassExpression>>(node).get());
-  } else if (current_node_type == parser::tokens::TypeExpression) {
-    node = std::make_unique<TypeExpression>();
-    Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
-  } else if (current_node_type == parser::tokens::NameExpression) {
-    node = std::make_unique<NameExpression>();
-    Visit(std::get<std::unique_ptr<NameExpression>>(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<DefinitionParameter>());
         Visit(node->parameters.back().get());
       } else {
-        node->arguments.push_back(std::make_unique<DefinitionArgument>());
+        node->arguments.emplace_back();
-        Visit(node->arguments.back().get());
+        Visit(&node->arguments.back());
       }
     }
   }
@@ -372,30 +352,7 @@ void BuildVisitor::Visit(DefinedName* node) {
   current_node_ = parse_node;
 }
 
-void BuildVisitor::Visit(DefinedAnnotatedName* node) {
+void BuildVisitor::Visit(TypeDefinition* 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<DefinedType>();
-      Visit(std::get<std::unique_ptr<DefinedType>>(node->type).get());
-    } else if (current_node_type == parser::tokens::DefinedTypeclass) {
-      node->type = std::make_unique<DefinedTypeclass>();
-      Visit(std::get<std::unique_ptr<DefinedTypeclass>>(node->type).get());
-    }
-
-    current_node_ = parse_node;
-  }
-}
-
-void BuildVisitor::Visit(DefinedType* 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 + 1 < child_count; ++i) {
-
-    for (size_t i = 0; i < child_count - 1; ++i) {
       current_node_ = parse_node.NthNamedChild(i + 1);
-
+      node->parameters.push_back(std::make_unique<DefinitionParameter>());
-      if (current_node_.GetType() != parser::tokens::DefinitionParameter) {
+      Visit(node->parameters.back().get());
-        parameters_ended = true;
-      }
-
-      if (!parameters_ended) {
-        node->parameters.push_back(std::make_unique<DefinitionParameter>());
-        Visit(node->parameters.back().get());
-      } else {
-        node->arguments.push_back(std::make_unique<DefinitionArgument>());
-        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<AnnotatedTypeclass>();
-  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<DefinitionParameter>());
-        Visit(node->parameters.back().get());
-      } else {
-        node->arguments.push_back(std::make_unique<DefinitionArgument>());
-        Visit(node->arguments.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);
-
+        Visit(node->typeclasses[i]);
-        std::string current_node_type = current_node_.GetType();
-
-        node->typeclasses[i] = std::make_unique<ParametrizedTypeclass>();
-
-        if (current_node_type == parser::tokens::TypeclassExpression) { // optimize ??
-          node->typeclasses[i]->typeclass_expression = std::make_unique<TypeclassExpression>();
-          Visit(node->typeclasses[i]->typeclass_expression.get());
-        } else if (current_node_type == parser::tokens::ParametrizedTypeclass) {
-          Visit(node->typeclasses[i].get());
-        } else {
-          // error
-        }
     }
   }
 
   current_node_ = parse_node;
 }
 
-void BuildVisitor::Visit(DefinitionArgument* node) {
+// TODO <-- fixes ended there
-  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<ParametrizedType>();
-
-        if (current_node_type == parser::tokens::TypeExpression) { // optimize ??
-          node->types[i]->type_expression = std::make_unique<TypeExpression>();
-          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<ParametrizedType>();
-    Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
-  } else if (current_node_type == parser::tokens::TupleType) {
-    node = std::make_unique<TupleType>();
-    Visit(std::get<std::unique_ptr<TupleType>>(node).get());
-  } else if (current_node_type == parser::tokens::VariantType) {
-    node = std::make_unique<VariantType>();
-    Visit(std::get<std::unique_ptr<VariantType>>(node).get());
-  } else if (current_node_type == parser::tokens::ParametrizedTypeclass) {
-    node = std::make_unique<ParametrizedTypeclass>();
-    Visit(std::get<std::unique_ptr<ParametrizedTypeclass>>(node).get());
-  } else {
-    // error
-  }
-
-  current_node_ = parse_node;
-}
 
 // 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 ??
+  if (current_node_type == parser::tokens::NameExpression) { // optimize ??
-    node = std::make_unique<NameSuperExpression>();
+    node = std::make_unique<NameExpression>();
-    Visit(std::get<std::unique_ptr<NameSuperExpression>>(node).get());
+    Visit(std::get<std::unique_ptr<NameExpression>>(node).get());
   } else if (current_node_type == parser::tokens::ScopedStatement) {
     node = std::make_unique<ScopedStatement>();
     Visit(std::get<std::unique_ptr<ScopedStatement>>(node).get());
@@ -867,12 +713,9 @@ void BuildVisitor::Visit(BlockStatement& node) {
   if (current_node_type == parser::tokens::Expression) { // optimize ??
     node = std::make_unique<Expression>();
     Visit(*std::get<std::unique_ptr<Expression>>(node));
-  } else if (current_node_type == parser::tokens::AliasDefinition) {
+  } else if (current_node_type == parser::tokens::VariableDefinitionStatement) {
-    node = std::make_unique<AliasDefinition>();
+    node = std::make_unique<VariableDefinitionStatement>();
-    Visit(std::get<std::unique_ptr<AliasDefinition>>(node).get());
+    Visit(std::get<std::unique_ptr<VariableDefinitionStatement>>(node).get());
-  } else if (current_node_type == parser::tokens::VariableDefinition) {
-    node = std::make_unique<VariableDefinition>();
-    Visit(std::get<std::unique_ptr<VariableDefinition>>(node).get());
   } else if (current_node_type == parser::tokens::FlowControl) {
     node = std::make_unique<FlowControl>();
     Visit(*std::get<std::unique_ptr<FlowControl>>(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<NameSuperExpression>();
+  node->name = std::make_unique<NameExpression>();
   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_;
+  auto parse_node = current_node_;
-  //
+
-  // current_node_ = parse_node.ChildByFieldName("type");
+  current_node_ = parse_node.ChildByFieldName("type");
-  // node->type = std::make_unique<ParametrizedType>();
+  node->type = std::make_unique<ParametrizedType>();
-  // Visit(node->type.get());
+  Visit(node->type.get());
-  //
+
-  // size_t parameter_count = (parse_node.NamedChildCount() - 1) / 2;
+  size_t parameter_count = (parse_node.NamedChildCount() - 1) / 2;
-  //
+
-  // node->parameters.resize(parameter_count);
+  node->parameters.resize(parameter_count);
-  //
+
-  // for (size_t i = 0; i < parameter_count * 2; ++i) {
+  for (size_t i = 0; i < parameter_count * 2; ++i) {
-  //   current_node_ = parse_node.NthNamedChild(i + 1);
+    current_node_ = parse_node.NthNamedChild(i + 1);
-  //
+
-  //   if (i % 2 == 0) {
+    if (i % 2 == 0) {
-  //     node->parameters[i / 2].first = current_node_.GetValue();
+      node->parameters[i / 2].first = current_node_.GetValue();
-  //   } else {
+    } else {
-  //     Visit(node->parameters[i / 2].second);
+      Visit(node->parameters[i / 2].second);
-  //   }
+    }
-  // }
+  }
-  //
+
-  // current_node_ = parse_node;
+  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());

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) {
+    if (node->modifier.has_value()) {
-      case Namespace::Const:
+      switch (node->modifier.value()) {
-        out_ << "const ";
+        case Namespace::Const:
-        break;
+          out_ << "const ";
-      case Namespace::Var:
+          break;
-        out_ << "var ";
+        case Namespace::Var:
-        break;
+          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 << "] ";
 }