diff --git a/include/build_visitor.hpp b/include/build_visitor.hpp
index 786439d..84296b6 100644
--- a/include/build_visitor.hpp
+++ b/include/build_visitor.hpp
@@ -16,7 +16,7 @@ public:
   }
 
 private:
-  void Visit(Node* node) override;
+  // // void Visit(Node* node) override;
 
   // Sources -----------------
 
@@ -56,6 +56,7 @@ private:
 
   // Flow control -----------------
 
+  void Visit(MatchCase* node) override;
   void Visit(Match* node) override;
   void Visit(Condition* node) override;
   void Visit(DoWhileLoop* node) override;
@@ -130,7 +131,7 @@ private:
 
   // Identifiers, constants, etc. -----------------
 
-  void Visit(AnyIdentifier* node) override; // std::string
+  // // void Visit(AnyIdentifier* node) override; // std::string
 
   void Visit(FloatNumberLiteral* node) override;
   void Visit(NumberLiteral* node) override;
diff --git a/include/interpreter_tree.hpp b/include/interpreter_tree.hpp
index f9fa6df..8c5f439 100644
--- a/include/interpreter_tree.hpp
+++ b/include/interpreter_tree.hpp
@@ -313,7 +313,7 @@ struct VariableDefinition : public Node {
 };
 
 struct FunctionDeclaration : public Node {
-  NameIdentifier name;
+  NameOrOperatorIdentifier name;
   std::vector<std::unique_ptr<DefinitionParameter>> parameters;
   std::vector<FunctionDeclarationType> argument_types;
 };
@@ -324,17 +324,18 @@ struct FunctionDefinition : public Node {
 };
 
 struct AliasTypeDefinition : public Node {
-  std::unique_ptr<DefinedType> name;
+  std::unique_ptr<DefinedType> type;
   std::unique_ptr<ParametrizedType> value;
 };
 
 struct TypeDefinition : public Node {
-  std::unique_ptr<DefinedType> name;
+  bool is_class; // class vs struct
+  std::unique_ptr<DefinedType> type;
   AnyType value;
 };
 
 struct TypeclassDefinition : public Node {
-  std::unique_ptr<DefinedTypeclass> name;
+  std::unique_ptr<DefinedTypeclass> typeclass;
   std::vector<std::unique_ptr<FunctionDeclaration>> requirements;
 };
 
@@ -497,7 +498,7 @@ struct VariantName : public Node {
 
 struct AnnotatedName : public Node {
   NameIdentifier name;
-  std::unique_ptr<ParametrizedType> type; // optional
+  std::optional<std::unique_ptr<ParametrizedType>> type; // optional
 };
 
 // TODO ?? mark all optional fields ??
diff --git a/include/parse_token_types.hpp b/include/parse_token_types.hpp
index d1de8ed..561af4a 100644
--- a/include/parse_token_types.hpp
+++ b/include/parse_token_types.hpp
@@ -14,6 +14,7 @@ const std::string Sources = "sources";
 // Namespaces, partittions -----------------
 
 const std::string Partition = "partition";
+const std::string Namespace = "namespace";
 
 // Definitions -----------------
 
@@ -57,11 +58,11 @@ const std::string FlowControl = "flow_control";
 const std::string Block = "block";
 const std::string ScopedStatement = "scoped_statement";
 
-const std::string LoopExpressionToken = "loop_expression_token";
+const std::string LoopControlExpression = "loop_control_expression";
 
-const std::string SubExpreessionToken = "subexpression_token";
+const std::string SubExpressionToken = "subexpression_token";
 const std::string SubExpression = "subexpression";
-const std::string PrefixedExprerssion = "prefixed_expression";
+const std::string PrefixedExpression = "prefixed_expression";
 const std::string Expression = "expression";
 const std::string SuperExpression = "super_expression";
 
@@ -76,7 +77,7 @@ const std::string UnaryOperatorExpression = "unary_operator_expression";
 
 const std::string FunctionCallExpression = "function_call_expression";
 const std::string TupleExpression = "tuple_expression";
-const std::string VarinatExpression = "variant_expression";
+const std::string VariantExpression = "variant_expression";
 const std::string ReturnExpression = "return_expression";
 
 const std::string FunctionArgument = "function_argument";
@@ -112,7 +113,7 @@ const std::string TypeParameter = "type_parameter";
 // Typeclass
 
 const std::string AnnotatedTypeclass = "annotated_typeclass";
-const std::string ParamatrizedTypeclass = "parametrized_typeclass";
+const std::string ParametrizedTypeclass = "parametrized_typeclass";
 const std::string TypeclassExpression = "typeclass_expression";
 
 // Identifiers, constants, etc. -----------------
diff --git a/include/print_visitor.hpp b/include/print_visitor.hpp
index 6b8347e..c1377c1 100644
--- a/include/print_visitor.hpp
+++ b/include/print_visitor.hpp
@@ -47,6 +47,7 @@ private:
 
   // Flow control -----------------
 
+  void Visit(MatchCase* node) override;
   void Visit(Match* node) override;
   void Visit(Condition* node) override;
   void Visit(DoWhileLoop* node) override;
diff --git a/include/visitor.hpp b/include/visitor.hpp
index a9523b4..1d5bfda 100644
--- a/include/visitor.hpp
+++ b/include/visitor.hpp
@@ -13,7 +13,7 @@ public:
     Visit(source_file);
   }
 
-private:
+protected:
   virtual void Visit(Node* node) {}
 
   // Sources -----------------
@@ -54,6 +54,7 @@ private:
 
   // Flow control -----------------
 
+  virtual void Visit(MatchCase* node) {}
   virtual void Visit(Match* node) {}
   virtual void Visit(Condition* node) {}
   virtual void Visit(DoWhileLoop* node) {}
diff --git a/src/build_visitor.cpp b/src/build_visitor.cpp
index 9bb3857..8d9731d 100644
--- a/src/build_visitor.cpp
+++ b/src/build_visitor.cpp
@@ -1,21 +1,19 @@
 // forclangd
 #include "../include/build_visitor.hpp"
 #include "../include/parse_token_types.hpp"
+#include <bits/utility.h>
+#include <memory>
 
 namespace interpreter {
 
-void BuildVisitor::Visit(Node* node) {
-  // error
-}
-
 // Sources -----------------
 void BuildVisitor::Visit(SourceFile* node) {
   auto parse_node = current_node_;
-  size_t child_count = parse_node.NamedChildCount();
+  size_t statement_count = parse_node.NamedChildCount();
 
-  node->statements.resize(child_count);
+  node->statements.resize(statement_count);
 
-  for (size_t i = 0; i < child_count; ++i) {
+  for (size_t i = 0; i < statement_count; ++i) {
       current_node_ = parse_node.NthNamedChild(i);
       auto current_node_type = current_node_.GetType();
 
@@ -32,11 +30,11 @@ void BuildVisitor::Visit(SourceFile* node) {
 
 void BuildVisitor::Visit(Sources* node) {
   auto parse_node = current_node_;
-  size_t child_count = parse_node.NamedChildCount();
+  size_t statement_count = parse_node.NamedChildCount();
 
-  node->statements.resize(child_count);
+  node->statements.resize(statement_count);
 
-  for (size_t i = 0; i < child_count; ++i) {
+  for (size_t i = 0; i < statement_count; ++i) {
       current_node_ = parse_node.NthNamedChild(i);
       Visit(node->statements[i]);
   }
@@ -66,427 +64,1048 @@ void BuildVisitor::Visit(Partition* node) {
   }
 
   current_node_ = parse_node.ChildByFieldName("scope");
-
   node->scope = std::make_unique<Sources>();
   Visit(node->scope.get());
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(Namespace* node) {
-  out_ << "<Namespace> ";
-  if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
+  auto parse_node = current_node_;
+
+  auto current_node_ = parse_node.ChildByFieldName("name");
+
+  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<DefinedAnnotatedName>();
     Visit(std::get<std::unique_ptr<DefinedAnnotatedName>>(node->name).get());
-  } else if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->name)) {
+  } 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());
-  } else {
-    // error
   }
-  out_ << "{\n";
+
+  current_node_ = parse_node.ChildByFieldName("scope");
+  node->scope = std::make_unique<Sources>();
   Visit(node->scope.get());
-  out_ << "} </Namespace>\n";
+
+  current_node_ = parse_node;
 }
 
 // Definitions -----------------
 
 void BuildVisitor::Visit(ImportStatement* node) {
-  out_ << "<Import> \"" << node->module_name << "\" ";
-  if (node->symbols.size() > 0) {
-    out_ << '\n';
+  auto parse_node = current_node_;
+
+  auto module_name_node = parse_node.ChildByFieldName("module_name");
+  node->module_name = module_name_node.NthChild(1).GetValue(); // open string literal
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  if (child_count > 1) {
+    node->symbols.resize(child_count - 1);
+
+    for (size_t i = 1; i < child_count; ++i) {
+        current_node_ = parse_node.NthNamedChild(i);
+        Visit(node->symbols[i]);
+    }
   }
-  for (auto& symbol : node->symbols) {
-    Visitor::Visit(symbol);
-    out_ << '\n';
-  }
-  out_ << "</Import>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(UsageDefinition* node) {
-  out_ << "<Usage> ";
-  Visit(&node->name);
-  out_ << " = ";
+  auto parse_node = current_node_;
+
+  node->name = parse_node.ChildByFieldName("name").GetValue();
+
+  current_node_ = parse_node.ChildByFieldName("import_statement");
+  node->import_statement = std::make_unique<ImportStatement>();
   Visit(node->import_statement.get());
-  out_ << "</Usage>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(AliasDefinition* node) {
-  out_ << "<Alias> ";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("type");
+  node->type = std::make_unique<DefinedType>();
   Visit(node->type.get());
-  out_ << " = ";
+
+  current_node_ = parse_node.ChildByFieldName("value");
+  node->value = std::make_unique<ParametrizedType>();
   Visit(node->value.get());
-  out_ << "</Alias>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(VariableDefinition* node) {
-  out_ << "<Variable> " << (node->is_const ? "const" : "var") << ' ';
-  Visit(&node->name);
-  out_ << " = ";
-  Visitor::Visit(node->value);
-  out_ << "</Variable>\n";
+  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;
+  }
+
+  node->name = parse_node.ChildByFieldName("name").GetValue();
+
+  current_node_ = parse_node.ChildByFieldName("value");
+  Visit(node->value);
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(FunctionDeclaration* node) {
-  out_ << "<FunctionDeclaration> ";
-  Visit(&node->name);
-  out_ << "\n";
-  for (auto& parameter : node->parameters) {
-    Visit(parameter.get());
+  auto parse_node = current_node_;
+
+  auto name_node = parse_node.ChildByFieldName("name");
+  std::string name = name_node.GetValue();
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  if (child_count > 1) {
+    bool parameters_ended = false;
+
+    for (size_t i = 1; i < child_count; ++i) {
+        current_node_ = parse_node.NthNamedChild(i);
+
+        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());
+        }
+    }
   }
-  out_ << " : \n";
-  for (auto& argument_type : node->argument_types) {
-    Visitor::Visit(argument_type);
-  }
-  out_ << "</FunctionDeclaration>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(FunctionDefinition* node) {
-  out_ << "<Function> ";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("name");
+  node->name = std::make_unique<DefinedName>();
   Visit(node->name.get());
-  out_ << " = ";
-  Visitor::Visit(node->value);
-  out_ << "</Function>\n";
+
+  current_node_ = parse_node.ChildByFieldName("value");
+  Visit(node->value);
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(AliasTypeDefinition* node) {
-  out_ << "<AliasType> ";
-  Visit(node->name.get());
-  out_ << " = ";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("type");
+  node->type = std::make_unique<DefinedType>();
+  Visit(node->type.get());
+
+  current_node_ = parse_node.ChildByFieldName("value");
+  node->value = std::make_unique<ParametrizedType>();
   Visit(node->value.get());
-  out_ << "</AliasType>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(TypeDefinition* node) {
-  out_ << "<Type> ";
-  Visit(node->name.get());
-  out_ << " = ";
-  Visitor::Visit(node->value);
-  out_ << "</Type>\n";
+  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");
+  node->type = std::make_unique<DefinedType>();
+  Visit(node->type.get());
+
+  current_node_ = parse_node.ChildByFieldName("value");
+  Visit(node->value);
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(TypeclassDefinition* node) {
-  out_ << "<Typeclass> ";
-  Visit(node->name.get());
-  if (node->requirements.size() > 0) {
-    out_ << " : \n";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("typeclass");
+  node->typeclass = std::make_unique<DefinedTypeclass>();
+  Visit(node->typeclass.get());
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  if (child_count > 1) {
+    node->requirements.resize(child_count - 1, std::make_unique<FunctionDeclaration>());
+
+    for (size_t i = 1; i < child_count; ++i) {
+        current_node_ = parse_node.NthNamedChild(i);
+        Visit(node->requirements[i].get());
+    }
   }
-  for (auto& requirement : node->requirements) {
-    out_ << "& ";
-    Visit(requirement.get());
+
+  current_node_ = parse_node;
+}
+
+//
+
+void BuildVisitor::Visit(SourceStatement& 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::ImportStatement) { // optimize ??
+    node = std::make_unique<ImportStatement>();
+    Visit(std::get<std::unique_ptr<ImportStatement>>(node).get());
+  } else if (current_node_type == parser::tokens::UsageDefinition) {
+    node = std::make_unique<UsageDefinition>();
+    Visit(std::get<std::unique_ptr<UsageDefinition>>(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) {
+    node = std::make_unique<FunctionDefinition>();
+    Visit(std::get<std::unique_ptr<FunctionDefinition>>(node).get());
+  } else if (current_node_type == parser::tokens::AliasTypeDefinition) {
+    node = std::make_unique<AliasTypeDefinition>();
+    Visit(std::get<std::unique_ptr<AliasTypeDefinition>>(node).get());
+  } else if (current_node_type == parser::tokens::TypeDefinition) {
+    node = std::make_unique<TypeDefinition>();
+    Visit(std::get<std::unique_ptr<TypeDefinition>>(node).get());
+  } else if (current_node_type == parser::tokens::TypeclassDefinition) {
+    node = std::make_unique<TypeclassDefinition>();
+    Visit(std::get<std::unique_ptr<TypeclassDefinition>>(node).get());
+  } else if (current_node_type == parser::tokens::Namespace) {
+    node = std::make_unique<Namespace>();
+    Visit(std::get<std::unique_ptr<Namespace>>(node).get());
+  } else {
+    // error
   }
-  out_ << "</Typeclass>\n";
+
+  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) {
-  out_ << "<DefinedName> ";
-  Visit(&node->name);
-  if (node->parameters.size() > 0) {
-    out_ << "\n";
+  auto parse_node = current_node_;
+
+  auto name_node = parse_node.ChildByFieldName("name"); // Operator or NameIdentifier
+  std::string name = name_node.GetValue();
+
+  node->is_operator = (parse_node.NthChild(0).GetValue() == "("); // TODO
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  if (child_count > 1) {
+    bool parameters_ended = false;
+
+    for (size_t i = 1; i < child_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+
+      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());
+      }
+    }
   }
-  for (auto& parameter : node->parameters) {
-    Visit(parameter.get());
-  }
-  if (node->arguments.size() > 0) {
-    out_ << " : \n";
-  }
-  for (auto& argument : node->arguments) {
-    Visit(argument.get());
-  }
-  out_ << "</DefinedName>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(DefinedAnnotatedName* node) {
-  out_ << "<DefinedAnnotatedName> ";
-  Visit(&node->name);
-  out_ << " : ";
-  if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->type)) {
-    Visit(std::get<std::unique_ptr<DefinedType>>(node->type).get());
-  } else if (std::holds_alternative<std::unique_ptr<DefinedTypeclass>>(node->type)) {
-    Visit(std::get<std::unique_ptr<DefinedTypeclass>>(node->type).get());
-  } else {
-    // no annotation
+  auto parse_node = current_node_;
+
+  auto name_node = parse_node.ChildByFieldName("name");
+  std::string name = name_node.GetValue();
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  if (child_count > 1) {
+    auto 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;
   }
-  out_ << " </DefinedAnnotatedName>";
 }
 
 void BuildVisitor::Visit(DefinedType* node) {
-  out_ << "<DefinedType> ";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("type");
+  node->type = std::make_unique<AnnotatedType>();
   Visit(node->type.get());
-  if (node->parameters.size() > 0) {
-    out_ << "\n";
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  if (child_count > 1) {
+    bool parameters_ended = false;
+
+    for (size_t i = 1; i < child_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+
+      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());
+      }
+    }
   }
-  for (auto& parameter : node->parameters) {
-    Visit(parameter.get());
-  }
-  if (node->arguments.size() > 0) {
-    out_ << " : \n";
-  }
-  for (auto& argument : node->arguments) {
-    Visit(argument.get());
-  }
-  out_ << "</DefinedType>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(DefinedTypeclass* node) {
-  out_ << "<DefinedTypeclass> ";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("typeclass");
+  node->typeclass = std::make_unique<AnnotatedTypeclass>();
   Visit(node->typeclass.get());
-  if (node->parameters.size() > 0) {
-    out_ << "\n";
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  if (child_count > 1) {
+    bool parameters_ended = false;
+
+    for (size_t i = 1; i < child_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+
+      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());
+      }
+    }
   }
-  for (auto& parameter : node->parameters) {
-    Visit(parameter.get());
-  }
-  if (node->arguments.size() > 0) {
-    out_ << " : \n";
-  }
-  for (auto& argument : node->arguments) {
-    Visit(argument.get());
-  }
-  out_ << "</DefinedTypeclass>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(DefinitionParameter* node) {
-  out_ << "<DefinitionParameter> " << (node->typeclasses.size() > 0 ? "(" : "");
-  Visit(&node->type);
-  out_ << ' ';
-  for (auto& typeclass : node->typeclasses) {
-    Visit(typeclass.get());
+  auto parse_node = current_node_;
+
+  auto name_node = parse_node.ChildByFieldName("type");
+  std::string name = name_node.GetValue();
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  if (child_count > 1) {
+    node->typeclasses.resize(child_count - 1, std::make_unique<ParametrizedTypeclass>());
+
+    for (size_t i = 1; i < child_count; ++i) {
+        current_node_ = parse_node.NthNamedChild(i);
+        Visit(node->typeclasses[i].get());
+        // choose between typeclass_expression and parametrized_typeclass
+    }
   }
-  out_ << "</DefinitionParamater>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(DefinitionArgument* node) {
-  out_ << "<DefinitionArgument> " << (node->types.size() > 0 ? "(" : "");
-  Visit(&node->name);
-  out_ << ' ';
-  for (auto& type : node->types) {
-    Visit(type.get());
+  auto parse_node = current_node_;
+
+  auto name_node = parse_node.ChildByFieldName("name");
+  std::string name = name_node.GetValue();
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  if (child_count > 1) {
+    node->types.resize(child_count - 1, std::make_unique<ParametrizedType>());
+
+    for (size_t i = 1; i < child_count; ++i) {
+        current_node_ = parse_node.NthNamedChild(i);
+        Visit(node->types[i].get());
+        // choose between type_expression and parametrized_type
+    }
   }
-  out_ << "</DefinitionArgument>\n";
+
+  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 -----------------
 
-void BuildVisitor::Visit(Match* node) {
-  out_ << "<Match> ";
-  Visitor::Visit(node->value);
-  out_ << " with\n";
-  for (auto& match_case : node->matches) {
-    out_ << "| ";
-    Visitor::Visit(match_case.value);
-    if (match_case.condition.has_value()) {
-      out_ << " ? ";
-      Visitor::Visit(match_case.condition.value());
+void BuildVisitor::Visit(MatchCase* node) {
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("value");
+  Visit(node->value);
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  if (child_count > 1) {
+    std::string prefix = parse_node.NthChild(3).GetValue(); // TODO
+
+    if (child_count > 2 || prefix == "?") {
+      current_node_ = parse_node.ChildByFieldName("condition");
+      node->condition.emplace();
+      Visit(node->condition.value());
     }
-    if (match_case.statement.has_value()) {
-      out_ << " -> ";
-      Visitor::Visit(match_case.statement.value());
+
+    if (child_count > 2 || prefix == "->") {
+      current_node_ = parse_node.ChildByFieldName("statement");
+      node->statement.emplace();
+      Visit(node->statement.value());
     }
-    out_ << '\n';
   }
-  out_ << "</Match>\n";
+
+  current_node_ = parse_node;
+}
+
+void BuildVisitor::Visit(Match* node) {
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("value");
+  Visit(node->value);
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  // if (child_count > 1) { // always true (repeat1)
+  node->matches.resize(child_count - 1);
+
+  for (size_t i = 1; i < child_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+      Visit(&node->matches[i]);
+  }
+  // }
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(Condition* node) {
-  out_ << "<If> ";
-  Visitor::Visit(node->conditions[0]);
-  out_ << " then\n";
-  Visitor::Visit(node->statements[0]);
-  out_ << '\n';
-  for (size_t i = 1; i < node->conditions.size(); ++i) {
-      out_ << "elif ";
-      Visitor::Visit(node->conditions[i]);
-      out_ << " then\n";
-      Visitor::Visit(node->statements[i]);
-      out_ << '\n';
+  auto parse_node = current_node_;
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  node->conditions.resize(child_count / 2);
+  node->statements.resize((child_count + 1) / 2);
+
+  for (size_t i = 0; i < child_count; ++i) {
+    current_node_ = parse_node.NthNamedChild(i);
+
+    if (i % 2 == 0 && i / 2 < node->conditions.size()) {
+      Visit(node->conditions[i / 2]);
+    } else {
+      Visit(node->statements[i / 2]);
+    }
   }
-  if (node->statements.size() > node->conditions.size()) {
-    out_ << "else ";
-    Visitor::Visit(node->statements[node->conditions.size()]);
-    out_ << '\n';
-  }
-  out_ << "</If>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(DoWhileLoop* node) {
-  out_ << "<DoWhile>\n";
-  Visitor::Visit(node->statement);
-  out_ << "\nwhile\n";
-  Visitor::Visit(node->condition);
-  out_ << "\n</DoWhile>\n";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("statement");
+  Visit(node->statement);
+
+  current_node_ = parse_node.ChildByFieldName("condition");
+  Visit(node->condition);
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(WhileLoop* node) {
-  out_ << "<While>\n";
-  Visitor::Visit(node->statement);
-  out_ << "\ndo\n";
-  Visitor::Visit(node->condition);
-  out_ << "\n</While>\n";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("condition");
+  Visit(node->condition);
+
+  current_node_ = parse_node.ChildByFieldName("statement");
+  Visit(node->statement);
+
+  current_node_ = parse_node;
 }
 void BuildVisitor::Visit(ForLoop* node) {
-  out_ << "<For>\n";
-  Visitor::Visit(node->variable);
-  out_ << "\nin\n";
-  Visitor::Visit(node->interval);
-  out_ << "\ndo\n";
-  Visitor::Visit(node->statement);
-  out_ << "</For>\n";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("variable");
+  Visit(node->variable);
+
+  current_node_ = parse_node.ChildByFieldName("interval");
+  Visit(node->interval);
+
+  current_node_ = parse_node.ChildByFieldName("statement");
+  Visit(node->statement);
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(LoopLoop* node) {
-  out_ << "<Loop>\n";
-  Visitor::Visit(node->statement);
-  out_ << "<\n/Loop>\n";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("statement");
+  Visit(node->statement);
+
+  current_node_ = parse_node;
+}
+
+void BuildVisitor::Visit(FlowControl& 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::Match) { // optimize ??
+    node = std::make_unique<Match>();
+    Visit(std::get<std::unique_ptr<Match>>(node).get());
+  } else if (current_node_type == parser::tokens::Condition) {
+    node = std::make_unique<Condition>();
+    Visit(std::get<std::unique_ptr<Condition>>(node).get());
+  } else if (current_node_type == parser::tokens::DoWhileLoop) {
+    node = std::make_unique<DoWhileLoop>();
+    Visit(std::get<std::unique_ptr<DoWhileLoop>>(node).get());
+  } else if (current_node_type == parser::tokens::WhileLoop) {
+    node = std::make_unique<WhileLoop>();
+    Visit(std::get<std::unique_ptr<WhileLoop>>(node).get());
+  } else if (current_node_type == parser::tokens::ForLoop) {
+    node = std::make_unique<ForLoop>();
+    Visit(std::get<std::unique_ptr<ForLoop>>(node).get());
+  } else if (current_node_type == parser::tokens::LoopLoop) {
+    node = std::make_unique<LoopLoop>();
+    Visit(std::get<std::unique_ptr<LoopLoop>>(node).get());
+  } else {
+    // error
+  }
+
+  current_node_ = parse_node;
 }
 
 // Statements, expressions, blocks, etc. -----------------
 
 void BuildVisitor::Visit(Block* node) {
-  out_ << "<Block> {\n";
-  for (auto& statement : node->statements) {
-    Visitor::Visit(statement);
+  auto parse_node = current_node_;
+  size_t statement_count = parse_node.NamedChildCount();
+
+  node->statements.resize(statement_count);
+
+  for (size_t i = 0; i < statement_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+      Visit(node->statements[i]);
   }
-  out_ << "} </Block>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(ScopedStatement* node) {
-  out_ << "<Scoped> ( ";
-  Visitor::Visit(node->statement);
-  out_ << " ) </Scoped>";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("statement");
+  Visit(node->statement);
+
+  current_node_ = parse_node;
+}
+
+void BuildVisitor::Visit(LoopControlExpression& node) {
+  std::string value = current_node_.NthChild(0).GetValue();
+
+  if (value == "break") {
+    node = LoopControlExpression::Break;
+  } else if (value == "continue") {
+    node = LoopControlExpression::Continue;
+  } else {
+    // error
+  }
+}
+
+//
+
+void BuildVisitor::Visit(SubExpressionToken& 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::NameExpression) { // optimize ??
+    node = std::make_unique<NameExpression>();
+    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());
+  } else {
+    // error
+  }
+
+  current_node_ = parse_node;
+}
+
+void BuildVisitor::Visit(SubExpression& 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::FunctionCallExpression) { // optimize ??
+    node = std::make_unique<FunctionCallExpression>();
+    Visit(std::get<std::unique_ptr<FunctionCallExpression>>(node).get());
+  } else if (current_node_type == parser::tokens::BinaryOperatorExpression) {
+    node = std::make_unique<BinaryOperatorExpression>();
+    Visit(std::get<std::unique_ptr<BinaryOperatorExpression>>(node).get());
+  } else if (current_node_type == parser::tokens::SubExpressionToken) {
+    node = std::make_unique<SubExpressionToken>();
+    Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node).get());
+  } else {
+    // error
+  }
+
+  current_node_ = parse_node;
+}
+
+void BuildVisitor::Visit(PrefixedExpression& 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::ReturnExpression) { // optimize ??
+    node = std::make_unique<ReturnExpression>();
+    Visit(std::get<std::unique_ptr<ReturnExpression>>(node).get());
+  } else if (current_node_type == parser::tokens::LoopControlExpression) {
+    node = std::make_unique<LoopControlExpression>();
+    Visit(*std::get<std::unique_ptr<LoopControlExpression>>(node).get());
+  } else if (current_node_type == parser::tokens::Block) {
+    node = std::make_unique<Block>();
+    Visit(std::get<std::unique_ptr<Block>>(node).get());
+  } else {
+    // error
+  }
+
+  current_node_ = parse_node;
+}
+
+void BuildVisitor::Visit(Expression& 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::LambdaFunction) { // optimize ??
+    node = std::make_unique<LambdaFunction>();
+    Visit(std::get<std::unique_ptr<LambdaFunction>>(node).get());
+  } else if (current_node_type == parser::tokens::TypeConstructor) {
+    node = std::make_unique<TypeConstructor>();
+    Visit(std::get<std::unique_ptr<TypeConstructor>>(node).get());
+  } else if (current_node_type == parser::tokens::PrefixedExpression) {
+    node = std::make_unique<PrefixedExpression>();
+    Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node).get());
+  } else if (current_node_type == parser::tokens::UnaryOperatorExpression) {
+    node = std::make_unique<UnaryOperatorExpression>();
+    Visit(std::get<std::unique_ptr<UnaryOperatorExpression>>(node).get());
+  } else if (current_node_type == parser::tokens::SubExpression) {
+    node = std::make_unique<SubExpression>();
+    Visit(*std::get<std::unique_ptr<SubExpression>>(node).get());
+  } else {
+    // error
+  }
+
+  current_node_ = parse_node;
+}
+
+void BuildVisitor::Visit(SuperExpression& 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::FlowControl) { // optimize ??
+    node = std::make_unique<FlowControl>();
+    Visit(*std::get<std::unique_ptr<FlowControl>>(node).get());
+  } else if (current_node_type == parser::tokens::TupleExpression) {
+    node = std::make_unique<TupleExpression>();
+    Visit(std::get<std::unique_ptr<TupleExpression>>(node).get());
+  } else if (current_node_type == parser::tokens::VariantExpression) {
+    node = std::make_unique<VariantExpression>();
+    Visit(std::get<std::unique_ptr<VariantExpression>>(node).get());
+  } else if (current_node_type == parser::tokens::Expression) {
+    node = std::make_unique<Expression>();
+    Visit(*std::get<std::unique_ptr<Expression>>(node).get());
+  } else {
+    // error
+  }
+
+  current_node_ = parse_node;
+}
+
+
+void BuildVisitor::Visit(BlockStatement& 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::Expression) { // optimize ??
+    node = std::make_unique<Expression>();
+    Visit(*std::get<std::unique_ptr<Expression>>(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::FlowControl) {
+    node = std::make_unique<FlowControl>();
+    Visit(*std::get<std::unique_ptr<FlowControl>>(node).get());
+  } else if (current_node_type == parser::tokens::PrefixedExpression) {
+    node = std::make_unique<PrefixedExpression>();
+    Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node).get());
+  } else {
+    // error
+  }
+
+  current_node_ = parse_node;
 }
 
 // Operators
 
 void BuildVisitor::Visit(BinaryOperatorExpression* node) {
-  out_ << "<BinaryOperator> ";
-  Visitor::Visit(node->left_expression);
-  out_ << ' ';
-  Visit(&node->operator_name);
-  out_ << ' ';
-  Visitor::Visit(node->right_expression);
-  out_ << " </BinaryOperator>";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("left_expression");
+  Visit(node->left_expression);
+
+  node->operator_name = parse_node.ChildByFieldName("operator_name").GetValue();
+
+  current_node_ = parse_node.ChildByFieldName("right_expression");
+  Visit(node->right_expression);
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(UnaryOperatorExpression* node) {
-  out_ << "<UnaryOperator> ";
-  Visit(&node->operator_name);
-  out_ << ' ';
-  Visitor::Visit(node->expression);
-  out_ << " </UnaryOperator>";
+  auto parse_node = current_node_;
+
+  node->operator_name = parse_node.ChildByFieldName("operator_name").GetValue();
+
+  current_node_ = parse_node.ChildByFieldName("expression");
+  Visit(node->expression);
+
+  current_node_ = parse_node;
 }
 
 // Simple Expressions
 
 void BuildVisitor::Visit(FunctionCallExpression* node) {
-  out_ << "<FunctionCall> ";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("name");
+  node->name = std::make_unique<NameSuperExpression>();
   Visit(node->name.get());
-  out_ << ' ';
-  for (auto& argument : node->arguments) {
-    Visitor::Visit(argument);
-    out_ << ' ';
+
+  size_t child_count = parse_node.NamedChildCount();
+
+  // if (child_count > 1) { // always true (repeat1)
+  node->arguments.resize(child_count - 1);
+
+  for (size_t i = 1; i < child_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+      Visit(node->arguments[i]);
   }
-  out_ << "</FunctionCall>";
+  // }
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(TupleExpression* node) {
-  out_ << "<TupleExpression> ";
-  out_ << ' ';
-  for (auto& expression : node->expressions) {
-    out_ << "& ";
-    Visitor::Visit(expression);
+  auto parse_node = current_node_;
+
+  size_t expressions_count = parse_node.NamedChildCount();
+
+  node->expressions.resize(expressions_count);
+
+  for (size_t i = 0; i < expressions_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+      Visit(node->expressions[i]);
   }
-  out_ << " </TupleExpression>";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(VariantExpression* node) {
-  out_ << "<VariantExpression> ";
-  out_ << ' ';
-  for (auto& expression : node->expressions) {
-    out_ << "& ";
-    Visitor::Visit(expression);
+  auto parse_node = current_node_;
+
+  size_t expressions_count = parse_node.NamedChildCount();
+
+  node->expressions.resize(expressions_count);
+
+  for (size_t i = 0; i < expressions_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+      Visit(node->expressions[i]);
   }
-  out_ << " </VariantExpression>";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(ReturnExpression* node) {
-  out_ << "<Return> ";
-  Visitor::Visit(node->expression);
-  out_ << " </Return>";
+  auto parse_node = current_node_;
+
+  current_node_ = parse_node.ChildByFieldName("expression");
+  Visit(node->expression);
+
+  current_node_ = parse_node;
+}
+
+//
+
+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) { // optimize ??
+    node = std::make_unique<SubExpressionToken>();
+    Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node).get());
+  } else if (current_node_type == parser::tokens::TypeSubExpression) {
+    node = std::make_unique<TypeSubExpression>();
+    Visit(*std::get<std::unique_ptr<TypeSubExpression>>(node).get());
+  } else {
+    // error
+  }
+
+  current_node_ = parse_node;
 }
 
 // Lambda
 
 void BuildVisitor::Visit(LambdaFunction* node) {
-  out_ << "<LambdaFunction> \\ ";
-  for (auto& parameter : node->parameters) {
-    Visit(parameter.get());
+  auto parse_node = current_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);
+
+        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());
+        }
+    }
   }
-  if (node->parameters.size() > 0) {
-    out_ << " : ";
-  }
-  for (auto& argument : node->arguments) {
-    Visit(argument.get());
-  }
-  out_ << " -> ";
-  Visitor::Visit(node->expression);
-  out_ << " </LambdaFunction>";
+
+  current_node_ = parse_node.ChildByFieldName("expression");
+  Visit(node->expression);
+
+  current_node_ = parse_node;
 }
 
 // Name
 
-void BuildVisitor::Visit(NameSuperExpression* node) {
-  out_ << "<NameSuperExpression> ";
-  for (auto& variable_namespace : node->namespaces) {
-    Visitor::Visit(variable_namespace);
-    out_ << '.';
-  }
-  for (int i = 0; i < node->expressions.size(); ++i) {
-    Visitor::Visit(node->expressions[i]);
-    if (i + 1 < node->expressions.size()) {
-      out_ << '.';
-    }
-  }
-  out_ << "</NameSupperExpression>\n";
+void BuildVisitor::Visit(NameSuperExpression* node) { // TODO
+  TODO;
 }
 
 void BuildVisitor::Visit(NameExpression* node) {
-  out_ << "<NameExpression> ";
-  for (auto& variable_namespace : node->namespaces) {
-    Visitor::Visit(variable_namespace);
-    out_ << '.';
-  }
-  for (int i = 0; i < node->names.size(); ++i) {
-    Visit(&node->names[i]);
-    if (i + 1 < node->names.size()) {
-      out_ << '.';
+  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());
+        }
     }
   }
-  out_ << "</NameExpression>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(TupleName* node) {
-  out_ << "<TupleName> ";
-  for (auto& name : node->names) {
-    out_ << '&';
-    Visit(name.get());
+  auto parse_node = current_node_;
+
+  size_t names_count = parse_node.NamedChildCount();
+
+  node->names.resize(names_count, std::make_unique<AnnotatedName>());
+
+  for (size_t i = 0; i < names_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+      Visit(node->names[i].get());
   }
-  out_ << "</TupleName>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(VariantName* node) {
-  out_ << "<VariantName> ";
-  for (auto& name : node->names) {
-    out_ << '|';
-    Visit(name.get());
+  auto parse_node = current_node_;
+
+  size_t names_count = parse_node.NamedChildCount();
+
+  node->names.resize(names_count, std::make_unique<AnnotatedName>());
+
+  for (size_t i = 0; i < names_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+      Visit(node->names[i].get());
   }
-  out_ << "</VariantName>\n";
+
+  current_node_ = parse_node;
 }
 
 void BuildVisitor::Visit(AnnotatedName* node) {
-  out_ << "<AnnotatedName> ";
-  Visit(&node->name);
-  out_ << ' ';
-  Visit(node->type.get());
-  out_ << " </AnnotatedName>";
+  auto parse_node = current_node_;
+
+  node->name = parse_node.ChildByFieldName("name").GetValue();
+
+  if (parse_node.ChildCount() > 1) {
+    current_node_ = parse_node.ChildByFieldName("type");
+    node->type = std::make_unique<ParametrizedType>();
+    Visit(node->type.value().get());
+
+    current_node_ = parse_node;
+  }
+}
+
+void BuildVisitor::Visit(AnyName& 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::AnnotatedName) { // optimize ??
+    node = std::make_unique<AnnotatedName>();
+    Visit(std::get<std::unique_ptr<AnnotatedName>>(node).get());
+  } else if (current_node_type == parser::tokens::TupleName) {
+    node = std::make_unique<TupleName>();
+    Visit(std::get<std::unique_ptr<TupleName>>(node).get());
+  } else if (current_node_type == parser::tokens::VariantName) {
+    node = std::make_unique<VariantName>();
+    Visit(std::get<std::unique_ptr<VariantName>>(node).get());
+  } else {
+    // error
+  }
+
+  current_node_ = parse_node;
 }
 
 // Type
@@ -601,24 +1220,69 @@ void BuildVisitor::Visit(TypeclassExpression* node) {
 
 // Identifiers, constants, etc. -----------------
 
-void BuildVisitor::Visit(AnyIdentifier* node) { // std::string
-  out_ << "<Identifier " << *node << " />";
-}
-
 void BuildVisitor::Visit(FloatNumberLiteral* node) {
-  out_ << "<Identifier " << node->value << " />";
+  node->value = current_node_.NthChild(0).GetValue();
 }
 
 void BuildVisitor::Visit(NumberLiteral* node) {
-  out_ << "<Number " << node->value << " />";
+  node->value = current_node_.NthChild(0).GetValue();
 }
 
 void BuildVisitor::Visit(StringLiteral* node) {
-  out_ << "<String " << node->value << " />";
+  node->value = current_node_.NthChild(1).GetValue();
 }
 
 void BuildVisitor::Visit(CharLiteral* node) {
-  out_ << "<Char " << node->value << " />";
+  node->value = current_node_.NthChild(1).GetValue();
+}
+
+void BuildVisitor::Visit(Literal& 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::FloatNumberLiteral) { // optimize ??
+    node = std::make_unique<FloatNumberLiteral>();
+    Visit(std::get<std::unique_ptr<FloatNumberLiteral>>(node).get());
+  } else if (current_node_type == parser::tokens::NumberLiteral) {
+    node = std::make_unique<NumberLiteral>();
+    Visit(std::get<std::unique_ptr<NumberLiteral>>(node).get());
+  } else if (current_node_type == parser::tokens::StringLiteral) {
+    node = std::make_unique<StringLiteral>();
+    Visit(std::get<std::unique_ptr<StringLiteral>>(node).get());
+  } else if (current_node_type == parser::tokens::CharLiteral) {
+    node = std::make_unique<CharLiteral>();
+    Visit(std::get<std::unique_ptr<CharLiteral>>(node).get());
+  } else {
+    // error
+  }
+
+  current_node_ = parse_node;
+}
+
+void BuildVisitor::Visit(NameSubSuperExpression& 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::NameIdentifier) { // optimize ??
+    node = std::make_unique<NameIdentifier>();
+    Visit(std::get<std::unique_ptr<NameIdentifier>>(node).get());
+  } else if (current_node_type == parser::tokens::Literal) {
+    node = std::make_unique<Literal>();
+    Visit(std::get<std::unique_ptr<Literal>>(node).get());
+  } else if (current_node_type == parser::tokens::SuperExpression) {
+    node = std::make_unique<SuperExpression>();
+    Visit(std::get<std::unique_ptr<SuperExpression>>(node).get());
+  } else {
+    // error
+  }
+
+  current_node_ = parse_node;
 }
 
 } // namespace interpreter
diff --git a/src/node.cpp b/src/node.cpp
index 0fbb3ad..fc38d58 100644
--- a/src/node.cpp
+++ b/src/node.cpp
@@ -5,8 +5,8 @@
 
 namespace interpreter {
 
-void Node::Accept(Visitor* visitor) {
+/*void Node::Accept(Visitor* visitor) {
   visitor->Visit(this);
-}
+}*/
 
 } // namespace interpreter
diff --git a/src/print_visitor.cpp b/src/print_visitor.cpp
index 8f70710..8d2f292 100644
--- a/src/print_visitor.cpp
+++ b/src/print_visitor.cpp
@@ -140,7 +140,7 @@ void PrintVisitor::Visit(FunctionDefinition* node) {
 
 void PrintVisitor::Visit(AliasTypeDefinition* node) {
   out_ << "<AliasType> ";
-  Visit(node->name.get());
+  Visit(node->type.get());
   out_ << " = ";
   Visit(node->value.get());
   out_ << "</AliasType>\n";
@@ -148,7 +148,7 @@ void PrintVisitor::Visit(AliasTypeDefinition* node) {
 
 void PrintVisitor::Visit(TypeDefinition* node) {
   out_ << "<Type> ";
-  Visit(node->name.get());
+  Visit(node->type.get());
   out_ << " = ";
   Visitor::Visit(node->value);
   out_ << "</Type>\n";
@@ -156,7 +156,7 @@ void PrintVisitor::Visit(TypeDefinition* node) {
 
 void PrintVisitor::Visit(TypeclassDefinition* node) {
   out_ << "<Typeclass> ";
-  Visit(node->name.get());
+  Visit(node->typeclass.get());
   if (node->requirements.size() > 0) {
     out_ << " : \n";
   }
@@ -259,22 +259,26 @@ void PrintVisitor::Visit(DefinitionArgument* node) {
 
 // Flow control -----------------
 
+void PrintVisitor::Visit(MatchCase* node) {
+  out_ << "<MatchCase> | ";
+  Visitor::Visit(node->value);
+  if (node->condition.has_value()) {
+    out_ << " ? ";
+    Visitor::Visit(node->condition.value());
+  }
+  if (node->statement.has_value()) {
+    out_ << " -> ";
+    Visitor::Visit(node->statement.value());
+  }
+  out_ << "</MatchCase>\n";
+}
+
 void PrintVisitor::Visit(Match* node) {
   out_ << "<Match> ";
   Visitor::Visit(node->value);
   out_ << " with\n";
   for (auto& match_case : node->matches) {
-    out_ << "| ";
-    Visitor::Visit(match_case.value);
-    if (match_case.condition.has_value()) {
-      out_ << " ? ";
-      Visitor::Visit(match_case.condition.value());
-    }
-    if (match_case.statement.has_value()) {
-      out_ << " -> ";
-      Visitor::Visit(match_case.statement.value());
-    }
-    out_ << '\n';
+    Visit(&match_case);
   }
   out_ << "</Match>\n";
 }
@@ -488,8 +492,10 @@ void PrintVisitor::Visit(VariantName* node) {
 void PrintVisitor::Visit(AnnotatedName* node) {
   out_ << "<AnnotatedName> ";
   Visit(&node->name);
-  out_ << ' ';
-  Visit(node->type.get());
+  if (node->type.has_value()) {
+    out_ << " : ";
+    Visit(node->type.value().get());
+  }
   out_ << " </AnnotatedName>";
 }