lang_2023/src/find_symbols_visitor.cpp

// for clangd
#include "../include/find_symbols_visitor.hpp"

// TODO

namespace interpreter {

// Sources -----------------
void FindSymbolsVisitor::Visit(SourceFile* node) {
  for (auto& statement : node->statements) {
    if (std::holds_alternative<Partition>(statement)) {
      Visit(&std::get<Partition>(statement));
    } else if (std::holds_alternative<SourceStatement>(statement)) {
      Visitor::Visit(std::get<SourceStatement>(statement));
    } else {
      // error
    }
  }
}

void FindSymbolsVisitor::Visit(Sources* node) {
  for (auto& statement : node->statements) {
    Visitor::Visit(statement);
  }
}

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

void FindSymbolsVisitor::Visit(Partition* node) {
  // TODO
  Visit(node->scope.get());
}

void FindSymbolsVisitor::Visit(Namespace* node) {
  std::optional<info::NamespaceInfo::Modifier> modifier;
  if (node->modifier.has_value()) {
    switch (node->modifier.value()) {
      case interpreter::Namespace::Var:
        modifier = info::NamespaceInfo::Var;
        break;
      case interpreter::Namespace::Const:
        modifier = info::NamespaceInfo::Const;
        break;
    }
  }

  std::optional<std::string> name;
  if (node->name.has_value()) {
    name = node->name.value().name;
  }

  namespace_visitor_.AddEnterNamespace(node->type, modifier, name);
  Visit(node->scope.get());
  namespace_visitor_.ExitNamespace();
}

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

// TODO: add imported symbols to symbol table (global info)
void FindSymbolsVisitor::Visit(ImportStatement* node) {
  is_in_statement = true;

  info::ImportInfo info;
  info.module_name = node->module_name;
  info.symbols = node->symbols;
  namespace_visitor_.AddImport(std::move(info), node->name);

  is_in_statement = false;
}

void FindSymbolsVisitor::Visit(AliasDefinitionStatement* node) {
  is_in_statement = true;

  info::TypeInfo info;

  info::AliasTypeInfo alias_info;

  switch (node->modifier) {
    case interpreter::AliasDefinitionStatement::Alias:
      alias_info.modifier = info::AliasTypeInfo::Alias;
      break;
    case interpreter::AliasDefinitionStatement::Type:
      alias_info.modifier = info::AliasTypeInfo::Type;
      break;
    case interpreter::AliasDefinitionStatement::Let:
      alias_info.modifier = info::AliasTypeInfo::Let;
      break;
  }
  alias_info.parameters = node->parameters;
  node->parameter_graph_ids_.resize(node->parameters.size());
  for (size_t i = 0; i < node->parameters.size(); ++i) {
    node->parameter_graph_ids_[i] = namespace_visitor_.GetAbstractTypeGraph()->AddVertex();
  }

  alias_info.value.node = node->value.get();

  info.type = std::move(alias_info);

  node->type_id_ = namespace_visitor_.AddType(node->type, std::move(info));

  is_in_statement = false;
}

void FindSymbolsVisitor::Visit(FunctionDeclaration* node) {
  bool was_in_statement = is_in_statement;
  is_in_statement = true;

  info::FunctionDeclarationInfo info;

  info.parameters.resize(node->parameters.size());
  for (size_t i = 0; i < node->parameters.size(); ++i) {
    Visit(node->parameters[i].get());
    info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
    current_info_.reset();
  }

  info.argument_types.resize(node->type->types.size());
  for (size_t i = 0; i < node->type->types.size(); ++i) {
    info.argument_type_nodes[i] = &node->type->types[i];
  }

  info.node = node;

  if (was_in_statement) {
    current_info_ = std::move(info);
  } else {
    node->function_id_ = namespace_visitor_.AddFunctionDeclaration(node->name.name, std::move(info));
    is_in_statement = false;
  }
}

void FindSymbolsVisitor::Visit(FunctionDefinitionStatement* node) {
  is_in_statement = true;

  info::FunctionDefinitionInfo info;

  auto definition = node->definition.get();

  info.parameters.resize(definition->parameters.size());
  for (size_t i = 0; i < definition->parameters.size(); ++i) {
    Visit(definition->parameters[i].get());
    info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
    current_info_.reset();
  }

  info.argument_names.resize(definition->arguments.size());
  node->argument_graph_ids_.resize(definition->arguments.size());
  for (size_t i = 0; i < definition->arguments.size(); ++i) {
    info.argument_names[i] = definition->arguments[i].name;
    node->argument_graph_ids_[i] = namespace_visitor_.GetAbstractTypeGraph()->AddVertex();
  }

  node->return_type_graph_id_ = namespace_visitor_.GetAbstractTypeGraph()->AddVertex();

  info.node = node;

  node->function_id_ = namespace_visitor_.AddFunctionDefinition(definition->name.name, std::move(info));

  is_in_statement = false;
}

void FindSymbolsVisitor::Visit(TypeDefinitionStatement* node) {
  is_in_statement = true;

  info::TypeInfo info;

  auto definition = node->definition.get();

  info::AnyTypeInfo any_type_info;

  Visit(definition->type.get());
  any_type_info.type = std::move(std::any_cast<info::ParameterInfo>(current_info_));
  current_info_.reset();

  any_type_info.parameters.resize(definition->parameters.size());
  for (size_t i = 0; i < definition->parameters.size(); ++i) {
    Visit(definition->parameters[i].get());
    any_type_info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
    current_info_.reset();
  }

  any_type_info.value = &node->value;

  std::string type = any_type_info.type.type;

  info.type = std::move(any_type_info);

  node->type_id_ = namespace_visitor_.AddType(type, std::move(info));

  is_in_statement = false;
}

void FindSymbolsVisitor::Visit(AbstractTypeDefinitionStatement* node) {
  is_in_statement = true;

  info::TypeInfo info;

  info::AbstractTypeInfo abstract_type_info;

  Visit(node->type.get());
  abstract_type_info.type = std::move(std::any_cast<info::ParameterInfo>(current_info_));
  current_info_.reset();

  switch (node->modifier) {
    case interpreter::AbstractTypeDefinitionStatement::Basic:
      abstract_type_info.modifier = info::AbstractTypeInfo::Basic;
      break;
    case interpreter::AbstractTypeDefinitionStatement::Abstract:
      abstract_type_info.modifier = info::AbstractTypeInfo::Abstract;
      break;
  }

  std::string type = abstract_type_info.type.type;

  info.type = std::move(abstract_type_info);

  node->type_graph_id_ = namespace_visitor_.GetAbstractTypeGraph()->AddVertex(); // ??
  node->type_id_ = namespace_visitor_.AddType(type, std::move(info));

  is_in_statement = false;
}

void FindSymbolsVisitor::Visit(TypeclassDefinitionStatement* node) {
  is_in_statement = true;

  info::TypeclassInfo info;

  auto definition = node->definition.get();

  info.parameters.resize(definition->parameters.size());
  for (size_t i = 0; i < definition->parameters.size(); ++i) {
    Visit(definition->parameters[i].get());
    info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
    current_info_.reset();
  }

  info.requirements.reserve(node->requirements.size());
  for (size_t i = 0; i < node->requirements.size(); ++i) {
    Visit(node->requirements[i].get());
    info.requirements[i] = std::move(std::any_cast<info::FunctionDeclarationInfo>(current_info_));
    current_info_.reset();
  }

  node->typeclass_id_ = namespace_visitor_.AddTypeclass(definition->type.get()->type, std::move(info));

  is_in_statement = false;
}

// Definition parts

void FindSymbolsVisitor::Visit(AnyAnnotatedType* node) {
  info::ParameterInfo info;

  info.type = node->type;

  info.typeclass_nodes.resize(node->typeclasses.size());
  for (size_t i = 0; i < node->typeclasses.size(); ++i) {
    info.typeclass_nodes[i] = node->typeclasses[i].get();
  }

  node->type_graph_id_ = namespace_visitor_.GetAbstractTypeGraph()->AddVertex();

  current_info_ = std::move(info);
}

} // namespace interpreter