lang_2023/src/build_visitor.cpp

#include <iostream>

#include <memory>
#include <sched.h>

// for clangd
#include "../include/build_visitor.hpp"
#include "../include/parse_token_types.hpp"

namespace interpreter {

// Sources -----------------
void BuildVisitor::Visit(SourceFile* node) {
  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);
      auto current_node_type = current_node_.GetType();

      if (current_node_type == parser::tokens::SourceStatement) {
        node->statements[i].emplace<SourceStatement>();
        Visit(std::get<SourceStatement>(node->statements[i]));
      } else if (current_node_type == parser::tokens::Partition) {
        node->statements[i].emplace<Partition>();
        Visit(&std::get<Partition>(node->statements[i]) );
      }
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(Sources* node) {
  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]);
  }

  current_node_ = parse_node;
}

// Namespaces, partitions -----------------

void BuildVisitor::Visit(Namespace* node) {
  auto parse_node = current_node_;

  size_t child_count = parse_node.NamedChildCount();

  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<Sources>();
  Visit(node->scope.get());

  current_node_ = parse_node;
}

void BuildVisitor::Visit(Partition* node) {
  auto parse_node = current_node_;

  std::string name = parse_node.ChildByFieldName("name").GetValue();

  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");
  node->scope = std::make_unique<Sources>();
  Visit(node->scope.get());

  current_node_ = parse_node;
}

// Definitions -----------------

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();
  ++excluded_child_count;

  size_t child_count = parse_node.NamedChildCount();

  if (child_count > excluded_child_count) {
    node->symbols.resize(child_count - excluded_child_count);

    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(AliasDefinitionStatement* node) {
  auto parse_node = current_node_;

  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;
  }

  node->type = parse_node.ChildByFieldName("type").GetValue();

  size_t child_count = parse_node.NamedChildCount();

  if (child_count > 2) {
    node->parameters.resize(child_count - 2);

    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<ParametrizedType>();
  Visit(node->value.get());

  current_node_ = parse_node;
}

void BuildVisitor::Visit(VariableDefinitionStatement* node) {
  auto parse_node = current_node_;

  std::string modifier = parse_node.NthChild(0).GetValue();
  if (modifier == "const") {
    node->modifier = VariableDefinitionStatement::Const;
  } else if (modifier == "var") {
    node->modifier = VariableDefinitionStatement::Var;
  }

  current_node_ = parse_node.ChildByFieldName("name");
  Visit(node->name);

  current_node_ = parse_node.ChildByFieldName("value");
  Visit(node->value);

  current_node_ = parse_node;
}

void BuildVisitor::Visit(FunctionDeclaration* node) {
  auto parse_node = current_node_;

  node->name = parse_node.ChildByFieldName("name").GetValue();

  size_t child_count = parse_node.NamedChildCount();

  for (size_t i = 0; i + 2 < child_count; ++i) {
      current_node_ = parse_node.NthNamedChild(i + 1);
      node->parameters.push_back(std::make_unique<DefinitionParameter>());
      Visit(node->parameters.back().get());
  }

  current_node_ = parse_node.ChildByFieldName("type");
  Visit(node->type.get());

  current_node_ = parse_node;
}

void BuildVisitor::Visit(FunctionDefinitionStatement* node) {
  auto parse_node = current_node_;

  current_node_ = parse_node.ChildByFieldName("definition");
  node->definition = std::make_unique<FunctionDefinition>();
  Visit(node->definition.get());

  current_node_ = parse_node.ChildByFieldName("value");
  Visit(node->value);

  current_node_ = parse_node;
}

void BuildVisitor::Visit(TypeDefinitionStatement* node) {
  auto parse_node = current_node_;

  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("definition");
  node->definition = std::make_unique<TypeDefinition>();
  Visit(node->definition.get());

  current_node_ = parse_node.ChildByFieldName("value");
  Visit(node->value);

  current_node_ = parse_node;
}

void BuildVisitor::Visit(AbstractTypeDefinitionStatement* node) {
  auto parse_node = current_node_;

  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<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 + 1 < child_count; ++i) {
        current_node_ = parse_node.NthNamedChild(i + 1);
        node->requirements[i] = std::make_unique<FunctionDeclaration>();
        Visit(node->requirements[i].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::AliasDefinitionStatement) {
    node = std::make_unique<AliasDefinitionStatement>();
    Visit(std::get<std::unique_ptr<AliasDefinitionStatement>>(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::FunctionDefinitionStatement) {
    node = std::make_unique<FunctionDefinitionStatement>();
    Visit(std::get<std::unique_ptr<FunctionDefinitionStatement>>(node).get());
  } else if (current_node_type == parser::tokens::TypeDefinitionStatement) {
    node = std::make_unique<TypeDefinitionStatement>();
    Visit(std::get<std::unique_ptr<TypeDefinitionStatement>>(node).get());
  } else if (current_node_type == parser::tokens::AbstractTypeDefinitionStatement) {
    node = std::make_unique<AbstractTypeDefinitionStatement>();
    Visit(std::get<std::unique_ptr<AbstractTypeDefinitionStatement>>(node).get());
  } else if (current_node_type == parser::tokens::TypeclassDefinitionStatement) {
    node = std::make_unique<TypeclassDefinitionStatement>();
    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());
  } else {
    // error
  }

  current_node_ = parse_node;
}

// Definition parts

void BuildVisitor::Visit(FunctionDefinition* node) {
  auto parse_node = current_node_;

  node->name = parse_node.ChildByFieldName("name").GetValue(); // TODO: check on operator

  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 + 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<DefinitionParameter>());
        Visit(node->parameters.back().get());
      } else {
        node->arguments.emplace_back();
        Visit(&node->arguments.back());
      }
    }
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(TypeDefinition* node) {
  auto parse_node = current_node_;

  current_node_ = parse_node.ChildByFieldName("type");
  node->type = std::make_unique<AnnotatedType>();
  Visit(node->type.get());

  size_t child_count = parse_node.NamedChildCount();

  if (child_count > 1) {
    for (size_t i = 0; i + 1 < child_count; ++i) {
      current_node_ = parse_node.NthNamedChild(i + 1);
      node->parameters.push_back(std::make_unique<DefinitionParameter>());
      Visit(node->parameters.back().get());
    }
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(DefinitionParameter* node) {
  auto parse_node = current_node_;

  node->type = parse_node.ChildByFieldName("type").GetValue();

  size_t child_count = parse_node.NamedChildCount();

  if (child_count > 1) {
    node->typeclasses.resize(child_count - 1);

    for (size_t i = 0; i + 1 < child_count; ++i) {
        current_node_ = parse_node.NthNamedChild(i + 1);
        Visit(node->typeclasses[i]);
    }
  }

  current_node_ = parse_node;
}

// TODO <-- fixes ended there

// Flow control -----------------

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(2).GetValue();

    if (child_count > 2 || prefix == "?") {
      current_node_ = parse_node.ChildByFieldName("condition");
      node->condition.emplace();
      Visit(node->condition.value());
    }

    if (child_count > 2 || prefix == "->") {
      current_node_ = parse_node.ChildByFieldName("statement");
      node->statement.emplace();
      Visit(node->statement.value());
    }
  }

  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 = 0; i < child_count - 1; ++i) {
      current_node_ = parse_node.NthNamedChild(i + 1);
      Visit(&node->matches[i]);
  }
  // }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(Condition* node) {
  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]);
    }
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(DoWhileLoop* node) {
  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) {
  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) {
  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) {
  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) {
  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]);
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(ScopedStatement* node) {
  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));
  } 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));
  } 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));
  } 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));
  } 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));
  } 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));
  } 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));
  } else if (current_node_type == parser::tokens::VariableDefinitionStatement) {
    node = std::make_unique<VariableDefinitionStatement>();
    Visit(std::get<std::unique_ptr<VariableDefinitionStatement>>(node).get());
  } else if (current_node_type == parser::tokens::FlowControl) {
    node = std::make_unique<FlowControl>();
    Visit(*std::get<std::unique_ptr<FlowControl>>(node));
  } else if (current_node_type == parser::tokens::PrefixedExpression) {
    node = std::make_unique<PrefixedExpression>();
    Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node));
  } else {
    // error
  }

  current_node_ = parse_node;
}

// Operators

void BuildVisitor::Visit(BinaryOperatorExpression* node) {
  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) {
  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) {
  auto parse_node = current_node_;

  current_node_ = parse_node.ChildByFieldName("name");
  node->name = std::make_unique<NameExpression>();
  Visit(node->name.get());

  size_t child_count = parse_node.NamedChildCount();

  // if (child_count > 1) { // always true (repeat1)
  node->arguments.resize(child_count - 1);

  for (size_t i = 0; i < child_count - 1; ++i) {
      current_node_ = parse_node.NthNamedChild(i + 1);
      Visit(node->arguments[i]);
  }
  // }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(TupleExpression* node) {
  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]);
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(VariantExpression* node) {
  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]);
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(ReturnExpression* node) {
  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));
  } else if (current_node_type == parser::tokens::TypeSubExpression) {
    node = std::make_unique<TypeSubExpression>();
    Visit(*std::get<std::unique_ptr<TypeSubExpression>>(node));
  } else {
    // error
  }

  current_node_ = parse_node;
}

// Lambda

void BuildVisitor::Visit(LambdaFunction* node) {
  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());
        }
    }
  }

  current_node_ = parse_node.ChildByFieldName("expression");
  Visit(node->expression);

  current_node_ = parse_node;
}

// Name

void BuildVisitor::Visit(NameExpression* node) {
  auto parse_node = current_node_;

  size_t child_count = parse_node.NamedChildCount();

  bool namespaces_ended = false;

  for (size_t i = 0; i < child_count; ++i) {
      current_node_ = parse_node.NthNamedChild(i);
      std::string current_node_type = current_node_.GetType();

      if (current_node_type != parser::tokens::TypeSubExpression && !namespaces_ended) {
        namespaces_ended = true;

        if (i + 1 == child_count) {
          node->expressions.emplace_back();

          if (current_node_type == parser::tokens::NameIdentifier) { // optimize ??
            node->expressions.back() = std::make_unique<NameIdentifier>(current_node_.GetValue());
          } else if (current_node_type == parser::tokens::Literal) {
            node->expressions.back() = std::make_unique<Literal>();
            Visit(*std::get<std::unique_ptr<Literal>>(node->expressions.back()));
          } else {
            // error
          }
          break;
        } else {
          // error
        }
      }

      if (!namespaces_ended) {
        node->namespaces.emplace_back();
        Visit(node->namespaces.back());
      } else {
        node->expressions.emplace_back();
        Visit(node->expressions.back());
      }
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(TupleName* node) {
  auto parse_node = current_node_;

  size_t names_count = parse_node.NamedChildCount();

  node->names.resize(names_count);

  for (size_t i = 0; i < names_count; ++i) {
      current_node_ = parse_node.NthNamedChild(i);
      node->names[i] = std::make_unique<AnnotatedName>();
      Visit(node->names[i].get());
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(VariantName* node) {
  auto parse_node = current_node_;

  size_t names_count = parse_node.NamedChildCount();

  node->names.resize(names_count);

  for (size_t i = 0; i < names_count; ++i) {
      current_node_ = parse_node.NthNamedChild(i);
      node->names[i] =std::make_unique<AnnotatedName>();
      Visit(node->names[i].get());
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(AnnotatedName* node) {
  auto parse_node = current_node_;

  node->name = parse_node.ChildByFieldName("name").GetValue();

  if (parse_node.NamedChildCount() > 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

void BuildVisitor::Visit(TypeConstructor* node) {
  auto parse_node = current_node_;

  current_node_ = parse_node.ChildByFieldName("type");
  node->type = std::make_unique<ParametrizedType>();
  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) {
  auto parse_node = current_node_;

  size_t current_node_n = 0;

  current_node_ = parse_node.NthNamedChild(current_node_n);

  if (current_node_.GetType() == parser::tokens::Constructor) {
    node->type = current_node_.GetValue(); // TODO check

    ++current_node_n;
    current_node_ = parse_node.NthNamedChild(current_node_n);
  }

  while (current_node_n < parse_node.NamedChildCount()) {
    node->entities.emplace_back();

    if (current_node_.GetType() == parser::tokens::NameIdentifier) {
      node->entities.back().first = current_node_.GetValue();

      ++current_node_n;
      current_node_ = parse_node.NthNamedChild(current_node_n);
    }

    Visit(node->entities.back().second);

    ++current_node_n;
    current_node_ = parse_node.NthNamedChild(current_node_n);
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(VariantType* node) {
  auto parse_node = current_node_;

  size_t current_node_n = 0;

  current_node_ = parse_node.NthNamedChild(current_node_n);

  if (current_node_.GetType() == parser::tokens::Constructor) {
    node->type = current_node_.GetValue(); // TODO check

    ++current_node_n;
    current_node_ = parse_node.NthNamedChild(current_node_n);
  }

  while (current_node_n < parse_node.NamedChildCount()) {
    std::string current_node_type = current_node_.GetType();

    node->constructors.emplace_back();

    if (current_node_type == parser::tokens::TypeIdentifierDefinition) { // optimize ??
      node->constructors.back() = current_node_.GetValue(); // TODO check
    } else if (current_node_type == parser::tokens::TupleType) {
      node->constructors.back() = std::make_unique<TupleType>();
      Visit(std::get<std::unique_ptr<TupleType>>(node->constructors.back()).get());
    } else {
      // error
    }

    ++current_node_n;
    current_node_ = parse_node.NthNamedChild(current_node_n);
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(AnnotatedType* node) {
  auto parse_node = current_node_;

  current_node_ = parse_node.ChildByFieldName("type_expression");
  node->type_expression = std::make_unique<TypeExpression>();
  Visit(node->type_expression.get());

  size_t child_count = parse_node.NamedChildCount();

  if (child_count > 1) {
    node->annotations.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->annotations[i] = std::make_unique<ParametrizedTypeclass>();

      if (current_node_type == parser::tokens::TypeclassExpression) { // optimize ??
        node->annotations[i]->typeclass_expression = std::make_unique<TypeclassExpression>();
        Visit(node->annotations[i]->typeclass_expression.get());
      } else if (current_node_type == parser::tokens::ParametrizedTypeclass) {
        Visit(node->annotations[i].get());
      } else {
        // error
      }
    }
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(ParametrizedType* node) {
  auto parse_node = current_node_;

  current_node_ = parse_node.ChildByFieldName("type_expression");
  node->type_expression = std::make_unique<TypeExpression>();
  Visit(node->type_expression.get());

  size_t child_count = parse_node.NamedChildCount();

  if (child_count > 1) {
    node->parameters.resize(child_count - 1);

    for (size_t i = 0; i < child_count - 1; ++i) {
        current_node_ = parse_node.NthNamedChild(i + 1);
        Visit(node->parameters[i]);
    }
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(TypeExpression* node) {
  auto parse_node = current_node_;

  size_t child_count = parse_node.NamedChildCount();

  if (child_count > 1) {
    node->namespaces.resize(child_count - 1);

    for (size_t i = 0; i < child_count - 1; ++i) {
        current_node_ = parse_node.NthNamedChild(i);
        Visit(node->namespaces[i]);
    }
  }

  node->type = parse_node.ChildByFieldName("type").GetValue();

  current_node_ = parse_node;
}

void BuildVisitor::Visit(AnyType& node) { // Or ScopedAnyType
  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 {
    // error
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(TypeSubExpression& 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::TypeIdentifier) { // optimize ??
    node = std::make_unique<TypeIdentifier>();
    Visit(std::get<std::unique_ptr<TypeIdentifier>>(node).get());
  } else if (current_node_type == parser::tokens::AbstractTypeIdentifier) {
    node = std::make_unique<AbstractTypeIdentifier>();
    Visit(std::get<std::unique_ptr<AbstractTypeIdentifier>>(node).get());
  } else if (current_node_type == parser::tokens::ParametrizedType) {
    node = std::make_unique<ParametrizedType>();
    Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
  } else {
    // error
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(TypeParameter& 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::TypeExpression) { // optimize ??
    node = std::make_unique<TypeExpression>();
    Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
  } else if (current_node_type == parser::tokens::ParametrizedType) {
    node = std::make_unique<ParametrizedType>();
    Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
  } else if (current_node_type == parser::tokens::Expression) {
    node = std::make_unique<Expression>();
    Visit(*std::get<std::unique_ptr<Expression>>(node));
  } else {
    // error
  }

  current_node_ = parse_node;
}

// Typeclass

void BuildVisitor::Visit(AnnotatedTypeclass* node) {
  auto parse_node = current_node_;

  current_node_ = parse_node.ChildByFieldName("typeclass_expression");
  node->typeclass_expression = std::make_unique<TypeclassExpression>();
  Visit(node->typeclass_expression.get());

  size_t child_count = parse_node.NamedChildCount();

  if (child_count > 1) {
    node->annotations.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->annotations[i] = std::make_unique<ParametrizedTypeclass>();

        if (current_node_type == parser::tokens::TypeclassExpression) { // optimize ??
          node->annotations[i]->typeclass_expression = std::make_unique<TypeclassExpression>();
          Visit(node->annotations[i]->typeclass_expression.get());
        } else if (current_node_type == parser::tokens::ParametrizedTypeclass) {
          Visit(node->annotations[i].get());
        } else {
          // error
        }
    }
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(ParametrizedTypeclass* node) {
  auto parse_node = current_node_;

  current_node_ = parse_node.ChildByFieldName("typeclass_expression");
  node->typeclass_expression = std::make_unique<TypeclassExpression>();
  Visit(node->typeclass_expression.get());

  size_t child_count = parse_node.NamedChildCount();

  if (child_count > 1) {
    node->parameters.resize(child_count - 1);

    for (size_t i = 0; i < child_count - 1; ++i) {
        current_node_ = parse_node.NthNamedChild(i + 1);
        Visit(node->parameters[i]);
    }
  }

  current_node_ = parse_node;
}

void BuildVisitor::Visit(TypeclassExpression* node) {
  auto parse_node = current_node_;

  size_t child_count = parse_node.NamedChildCount();

  if (child_count > 1) {
    node->namespaces.resize(child_count - 1);

    for (size_t i = 0; i < child_count - 1; ++i) {
        current_node_ = parse_node.NthNamedChild(i);
        Visit(node->namespaces[i]);
    }
  }

  node->typeclass = parse_node.ChildByFieldName("typeclass").GetValue();

  current_node_ = parse_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();
}

void BuildVisitor::Visit(FloatNumberLiteral* node) {
  node->value = std::stod(current_node_.GetValue());
}

void BuildVisitor::Visit(NumberLiteral* node) {
  node->value = std::stoll(current_node_.GetValue());
}

void BuildVisitor::Visit(StringLiteral* node) {
  node->value = current_node_.NthChild(1).GetValue();
}

void BuildVisitor::Visit(CharLiteral* node) {
  node->value = current_node_.NthChild(1).GetValue()[0];
}

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>(current_node_.GetValue());
    //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));
  } else if (current_node_type == parser::tokens::SuperExpression) {
    node = std::make_unique<SuperExpression>();
    Visit(*std::get<std::unique_ptr<SuperExpression>>(node));
  } else {
    // error
  }

  current_node_ = parse_node;
}

} // namespace interpreter