lang_2023/src/link_symbols_visitor.cpp

// for clangd
#include "../include/link_symbols_visitor.hpp"
#include "../include/error_handling.hpp"
#include <optional>

namespace interpreter {

const std::string& NameFromTypeSubExpression(const TypeSubExpression& type) {
  if (std::holds_alternative<std::unique_ptr<std::string>>(type)) {
    return *std::get<std::unique_ptr<std::string>>(type);
  } else if (std::holds_alternative<std::unique_ptr<ParametrizedType>>(type)) {
    return std::get<std::unique_ptr<ParametrizedType>>(type)->type;
  }

  error_handling::HandleInternalError("Empty variant", "NameFromTypeSubExpression");
  exit(1); // TODO: better decision ??
}

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

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

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

  std::optional<utils::IdType> maybe_typeclass;
  if (namespace_visitor_.GetCurrentPath().size() == 0) {
    maybe_typeclass = namespace_visitor_.FindTypeclass(node->type);
  }

  if (maybe_type.has_value() && maybe_typeclass.has_value()) {
    error_handling::HandleTypecheckError("Ambigious namespace name (typeclass or type)");
  }
  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);

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

  namespace_visitor_.ExitNamespace();
}

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

// Type

// TODO: link internal stages
void LinkSymbolsVisitor::Visit(TypeExpression* node) { // TODO: check
  std::vector<std::string> path;
  path.reserve(node->path.size());

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

  std::optional<utils::IdType> maybe_type = namespace_visitor_.FindType(path, NameFromTypeSubExpression(node->type));

  if (maybe_type.has_value()) {
    node->type_id_ = maybe_type.value();
  } else {
    error_handling::HandleTypecheckError("Type not found");
  }
}

// Typeclass

void LinkSymbolsVisitor::Visit(TypeclassExpression* node) { // TODO: check
  std::string typeclass;

  if (std::holds_alternative<std::unique_ptr<std::string>>(node->typeclass)) {
    typeclass = *std::get<std::unique_ptr<std::string>>(node->typeclass);
  } else if (std::holds_alternative<std::unique_ptr<ParametrizedTypeclass>>(node->typeclass)) {
    typeclass = std::get<std::unique_ptr<ParametrizedTypeclass>>(node->typeclass)->typeclass;
  } else {
    // error
  }

  std::optional<utils::IdType> maybe_typeclass = namespace_visitor_.FindTypeclass(typeclass);

  if (maybe_typeclass.has_value()) {
    node->typeclass_id_ = maybe_typeclass.value();
  } else {
    error_handling::HandleTypecheckError("Type not found");
  }
}

} // namespace interpreter