lang_2023/src/link_symbols_visitor.cpp

#include <optional>

// for clangd
#include "../include/link_symbols_visitor.hpp"
#include "../include/error_handling.hpp"
#include "../include/types.hpp"

namespace interpreter {

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

void LinkSymbolsVisitor::Visit(Namespace* node) {
  // Visitor::Visit(&node->type); // not needed

  std::optional<utils::IdType> maybe_type = namespace_visitor_.FindLocalTypeId(node->type);

  std::optional<utils::IdType> maybe_typeclass;
  if (namespace_visitor_.IsInGlobalNamespace()) {
    maybe_typeclass = namespace_visitor_.FindTypeclassId(node->type);
  }

  if (maybe_type.has_value() && maybe_typeclass.has_value()) {
    error_handling::HandleNamesError("Ambigious namespace name (typeclass or type)", node->base);
  }

  if (maybe_type.has_value()) {
    node->link_type_id_ = maybe_type.value();
  }
  if (maybe_typeclass.has_value()) {
    node->link_typeclass_id_ = maybe_typeclass.value();
  }

  namespace_visitor_.EnterNamespace(node->type, node->modifier);

  Visitor::Visit(&node->scope);

  namespace_visitor_.ExitNamespace();
}

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

void LinkSymbolsVisitor::Visit(TypeclassDefinitionStatement* node) {
  Visitor::Visit(node->definition.get());
  for (auto& function_requirement : node->requirements) {
    namespace_visitor_.EnterNamespace(node->definition->type->type, function_requirement.first);
    Visitor::Visit(function_requirement.second.get());
    namespace_visitor_.ExitNamespace();
  }

  auto maybe_graph_id = namespace_visitor_.GetGlobalInfo()->AddTypeclassToGraph(node->typeclass_id_);
  if (!maybe_graph_id.has_value()) {
    error_handling::HandleNamesError("Can't add typeclass to graph", node->base);
  }
  namespace_visitor_.GetGlobalInfo()->GetTypeclassInfo(node->typeclass_id_).graph_id_ = maybe_graph_id.value();
}

// Type, typeclass, etc. -----------------

// Type

void LinkSymbolsVisitor::Visit(TypeExpression* node) {
  std::vector<std::string> path;
  path.reserve(node->path.size());

  for (auto& path_type : node->path) {
    path.push_back(path_type.type);
  }

  node->type_id_ = namespace_visitor_.FindTypeId(path, node->type.type);
  node->constructor_id_ = namespace_visitor_.FindConstructorId(path, node->type.type);

  // internal type
  if (info::type::ToInternalType(node->type.type).has_value()) {
    if (!node->path.empty()) {
      error_handling::HandleNamesError("Internal type is not in namespace", node->base);
    }

    if (!node->type.parameters.empty()) {
      error_handling::HandleNamesError("Can't parametrize internal type", node->base);
    }
    return;
  }

  // check made in typecheck visitor ??
  //////////////////////////////////////////////////////////
  // abstract / basic / TODO: local abstract type
  // if (path.size() == 0 && (namespace_visitor_.FindAbstractType(node->type.type).has_value()) {
  //   return;
  // }
  //////////////////////////////////////////////////////////

  if (!node->type_id_.has_value() && !node->constructor_id_.has_value()) {
    // check made in typecheck visitor ??
    return;
  }

  if (node->constructor_id_.has_value()) {
    utils::IdType constructor_type_id = namespace_visitor_.GetGlobalInfo()->GetConstructorInfo(node->constructor_id_.value()).type_id;

    if (node->type_id_.has_value() && node->type_id_.value() != constructor_type_id) {
      error_handling::HandleNamesError("Contructor and type with same name have different types", node->base);
    }

    node->type_id_ = constructor_type_id;
  }

  if (node->type_id_.has_value()) {
    node->type.type_id_ = node->type_id_.value();
  }

  std::optional<info::definition::Namespace*> maybe_type_namespace = namespace_visitor_.FindNamespace(path);
  if (maybe_type_namespace.has_value()) {
    info::definition::Namespace* type_namespace = maybe_type_namespace.value();

    for (ssize_t i = (ssize_t)node->path.size(); i >= 0; --i) {
      info::definition::Namespace* parent_namespace = &namespace_visitor_.GetGlobalInfo()->GetNamespaceInfo(type_namespace->parent_namespace);

      auto type_iter = parent_namespace->types.find(type_namespace->type_name);
      if (type_iter != parent_namespace->types.end()) {
        node->path[i].type_id_ = type_iter->second;
      }

      type_namespace = parent_namespace;
    }
  }
}

// Typeclass

void LinkSymbolsVisitor::Visit(ParametrizedTypeclass* node) {
  std::optional<utils::IdType> maybe_typeclass = namespace_visitor_.FindTypeclassId(node->typeclass);

  if (maybe_typeclass.has_value()) {
    node->typeclass_id_ = maybe_typeclass.value();
  } else {
    error_handling::HandleNamesError("Typeclass not found", node->base);
  }

  if (node->parameters.size() > 0) {
    error_handling::HandleNamesError("Parametrized typeclasses not implemented yet", node->base);
  }
}

} // namespace interpreter