lang_2023/include/global_info.hpp

#pragma once

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

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

namespace info {

// TODO: partitions
class GlobalInfo {
  friend class NamespaceVisitor;
public:
  class NamespaceVisitor {
    friend GlobalInfo;
    NamespaceVisitor() = delete;
  public:
    void AddImport(ImportInfo&& import_info, const std::optional<std::string>& name = std::nullopt);

    void AddEnterNamespace(const std::string& name,
                          const std::optional<NamespaceInfo::Modifier>& modifier = std::nullopt,
                          const std::optional<std::string>& variable = std::nullopt);

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

    void ExitNamespace();

    void ToGlobalNamespace();

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

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

    utils::IdType AddType(const std::string& type, TypeInfo&& type_info);

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

    std::optional<NamespaceInfo*> 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> FindTypeclass(const std::optional<std::vector<std::string>>& path,
                                               const std::string typeclass);
  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*>(NamespaceInfo*)> search_func);

    std::optional<NamespaceInfo*> FindNamespaceIn(NamespaceInfo* current_namespace,
                                                  const std::vector<std::string>& path);
  private:
    std::vector<NamespaceInfo*> namespace_stack_;

    GlobalInfo& global_info_;
  };

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

  FunctionInfo* GetFunctionInfo(utils::IdType id) {
    return functions_.GetValue(id);
  }

  TypeInfo* GetTypeInfo(utils::IdType id) {
    return types_.GetValue(id);
  }

  TypeclassInfo* GetTypeclassInfo(utils::IdType id) {
    return typeclasses_.GetValue(id);
  }

private:
  utils::Storage<FunctionInfo*> functions_;
  utils::Storage<TypeInfo*> types_;
  utils::Storage<TypeclassInfo*> typeclasses_;

  NamespaceInfo global_namespace_;
  std::vector<ImportInfo> imports_;
  std::unordered_map<std::string, ImportInfo> usages_;
};

} // namespace info