lang_2023/include/global_info.hpp

#pragma once

#include <string>
#include <functional>
#include <unordered_map>

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

namespace info {

// TODO: partitions
class GlobalInfo {
  friend class NamespaceVisitor;
public:
  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,
                           const std::optional<definition::Namespace::Modifier>& modifier = std::nullopt);

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

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

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

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

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

    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_;
    }
  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:
    std::vector<definition::Namespace*> namespace_stack_;
    std::vector<std::string> current_path_;

    GlobalInfo& global_info_;
  };

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

  // remember about vector realloc
  definition::Function* GetFunctionInfo(utils::IdType id) {
    return &functions_[id];
  }

  // remember about vector realloc
  definition::Type* GetTypeInfo(utils::IdType id) {
    return &types_[id];
  }

  // remember about vector realloc
  definition::Typeclass* GetTypeclassInfo(utils::IdType id) {
    return &typeclasses_[id];
  }

  // remember about vector realloc
  definition::Constructor* GetConstructorInfo(utils::IdType id) {
    return &constructors_[id];
  }

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

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

} // namespace info