lang_2023/include/global_info.hpp

#pragma once

#include <asm-generic/errno.h>
#include <string>
#include <functional>
#include <unordered_map>

// for clangd
#include "definitions.hpp"
#include "interpreter_tree.hpp"
#include "utils.hpp"

namespace info {

// TODO: better test / executable partitions support (tree, etc.)
// TODO: add classes / structs and functions module interface
class GlobalInfo {
  friend class NamespaceVisitor;
public:
  struct PartitionInfo {
    std::vector<std::string> path;
    std::string name;
    interpreter::tokens::PartitionStatement* node = nullptr;
  };

  class NamespaceVisitor {
    friend GlobalInfo;
    NamespaceVisitor() = delete;
  public:

    struct Path {
      std::vector<std::optional<utils::IdType>> path_types;
      definition::Namespace* result;
    };

    void AddImport(definition::Import&& import_info, const std::optional<std::string>& name = std::nullopt);

    void AddEnterNamespace(const std::string& name,
                           std::optional<utils::IsConstModifier> modifier,
                           const interpreter::tokens::BaseNode& base_node);

    void EnterNamespace(const std::string& name);

    void ExitNamespace();

    void ToGlobalNamespace();

    utils::IdType AddFunctionDeclaration(const std::string& name,
                                         definition::FunctionDeclaration&& function_declaration_info);

    utils::IdType AddFunctionDefinition(const std::string& name,
                                        definition::FunctionDefinition&& function_definition_info);

    utils::IdType AddType(const std::string& type,
                          definition::Type&& type_info,
                          const interpreter::tokens::BaseNode& base_node);

    utils::IdType AddAbstractType(const std::string& abstract_type,
                                  definition::AbstractType&& abstract_type_info,
                                  const interpreter::tokens::BaseNode& base_node);

    utils::IdType AddTypeclass(const std::string& typeclass,
                               definition::Typeclass&& typeclass_info,
                               const interpreter::tokens::BaseNode& base_node);

    utils::IdType AddConstructor(const std::string& constructor,
                                 definition::Constructor&& constructor_info,
                                 const interpreter::tokens::BaseNode& base_node);

    utils::IdType AddPartition(const std::vector<std::string>& path, // including name
                               interpreter::tokens::PartitionStatement* node);

    std::optional<definition::Namespace*> FindNamespace(const std::optional<std::vector<std::string>>& path);

    std::optional<utils::IdType> FindFunction(const std::optional<std::vector<std::string>>& path,
                                              const std::string& name);

    std::optional<utils::IdType> FindMethod(const std::optional<std::vector<std::string>>& path,
                                            const std::string& type,
                                            const std::string& name,
                                            utils::IsConstModifier modifier);

    std::optional<utils::IdType> FindType(const std::optional<std::vector<std::string>>& path,
                                          const std::string& type);

    std::optional<utils::IdType> FindLocalType(const std::string& type);

    std::optional<utils::IdType> FindAbstractType(const std::string& abstract_type);

    std::optional<utils::IdType> FindTypeclass(const std::string& typeclass);

    std::optional<utils::IdType> FindConstructor(const std::optional<std::vector<std::string>>& path,
                                                 const std::string& constructor);

    NamespaceVisitor CreateVisitor() {
      return global_info_.CreateVisitor();
    }

    GlobalInfo* GetGlobalInfo() {
      return &global_info_;
    }

    const std::vector<std::string>& GetCurrentPath() {
      return current_path_;
    }

    definition::Namespace* GetCurrentNamespace() {
      return namespace_stack_.back();
    }
  private:
    NamespaceVisitor(GlobalInfo& global_info) : global_info_(global_info),
                                                namespace_stack_({&global_info.global_namespace_}) {}

    template<typename T>
    std::optional<T> FindSomething(
      const std::optional<std::vector<std::string>>& path,
      std::function<std::optional<T>(definition::Namespace*)> search_func);

    std::optional<definition::Namespace*> FindNamespaceIn(
      definition::Namespace* current_namespace,
      const std::vector<std::string>& path);
  private:
    GlobalInfo& global_info_;

    std::vector<definition::Namespace*> namespace_stack_;
    std::vector<std::string> current_path_;
  };

  NamespaceVisitor CreateVisitor() {
    return NamespaceVisitor(*this);
  }

  // remember about vector realloc
  const definition::Function& GetFunctionInfo(utils::IdType id) {
    return functions_.at(id);
  }

  template<typename T>
  std::optional<T*> GetTypeInfo(utils::IdType id) {
    if (!std::holds_alternative<T>(types_.at(id).type)) {
      return std::nullopt;
    }
    return &std::get<T>(types_[id].type);
  }

  // remember about vector realloc
  const definition::Type& GetAnyTypeInfo(utils::IdType id) {
    return types_.at(id);
  }

  // remember about vector realloc
  const definition::Typeclass& GetTypeclassInfo(utils::IdType id) {
    return typeclasses_.at(id);
  }

  // remember about vector realloc
  const definition::Constructor& GetConstructorInfo(utils::IdType id) {
    return constructors_.at(id);
  }

  // remember about vector realloc
  const PartitionInfo& GetPartitionInfo(utils::IdType id) {
    return partitions_.at(id);
  }

  std::optional<utils::IdType> FindPartition(const std::vector<std::string>& path) {
    auto trie_ans = partitions_trie_.Find(path);
    return trie_ans.has_value() ? std::optional<utils::IdType>(*trie_ans.value()) : std::nullopt;
  }

  std::vector<utils::IdType> FindPartitionsByPrefix(const std::vector<std::string>& path) { // optimize ??
    auto trie_ans = partitions_trie_.FindByPrefix(path);

    std::vector<utils::IdType> ans(trie_ans.size());

    for (size_t i = 0; i < ans.size(); ++i) {
      ans[i] = *trie_ans[i];
    }

    return ans;
  }

private:

  std::vector<definition::Function> functions_;
  std::vector<definition::Type> types_;
  std::vector<definition::AbstractType> abstract_types_;
  std::vector<definition::Typeclass> typeclasses_;
  std::vector<definition::Constructor> constructors_;

  std::unordered_map<std::string, utils::IdType> name_to_typeclass_;
  std::unordered_map<std::string, utils::IdType> name_to_abstract_type_;

  std::vector<PartitionInfo> partitions_;
  utils::Trie<std::string, utils::IdType> partitions_trie_;

  definition::Namespace global_namespace_;
  std::vector<definition::Import> imports_;
  std::unordered_map<std::string, definition::Import> usages_;
};

} // namespace info