lang_2023/include/types.hpp

#pragma once

#include <optional>
#include <string>
#include <variant>
#include <memory>
#include <unordered_set>

// for clangd
#include "utils.hpp"

namespace info::type {

// TODO: move in constructors

class TypeManager;

class AbstractType { // later will be found in context
public:
  AbstractType() = default;
  AbstractType(const std::string& name,
               const std::vector<utils::IdType>& requirements) : name_(name) {
    for (auto& typeclass : requirements) {
      requirements_.insert(typeclass);
    }
  }

  bool Same(const AbstractType& type) const;
  bool operator<(const AbstractType& type) const;
  bool operator>(const AbstractType& type) const;
private:
  std::string name_;
  std::unordered_set<utils::IdType> requirements_; // TODO: all typeclasses from tree
};

class DefinedType {
public:
  DefinedType() = default;
  DefinedType(utils::IdType type_id,
              utils::IdType type,
              TypeManager* type_manager)
    : type_id_(type_id), type_(type), type_manager_(type_manager) {}

  bool Same(const DefinedType& type) const;
  bool operator<(const DefinedType& type) const;
  bool operator>(const DefinedType& type) const;
private:
  utils::IdType type_id_; // in defined types
  utils::IdType type_; // in types manager, created using context types (if specific type)
  TypeManager* type_manager_ = nullptr;
};

enum class InternalType {
  Float = 0,
  Int = 1,
  String = 2,
  Char = 3,
  Bool = 4,
  Unit = 5,
};

class TupleType {
public:
  TupleType() = default;
  TupleType(const std::optional<std::string>& name,
            const std::vector<std::pair<std::optional<std::string>, utils::IdType>>& fields,
            TypeManager* type_manager)
    : name_(name), fields_(fields), type_manager_(type_manager) {}

  bool Same(const TupleType& type) const;
  bool operator<(const TupleType& type) const;
  bool operator>(const TupleType& type) const;
private:
  std::optional<std::string> name_;
  std::vector<std::pair<std::optional<std::string>, utils::IdType>> fields_;
  TypeManager* type_manager_ = nullptr;
};

class VariantType {
public:
  VariantType() = default;
  VariantType(const std::optional<std::string>& name,
              const std::vector<TupleType>& constructors)
    : name_(name), constructors_(constructors){}

  bool Same(const VariantType& type) const;
  bool operator<(const VariantType& type) const;
  bool operator>(const VariantType& type) const;
private:
  std::optional<std::string> name_;
  std::vector<TupleType> constructors_;
};

class OptionalType {
public:
  OptionalType() = default;
  OptionalType(utils::IdType type,
               TypeManager* type_manager)
    : type_(type), type_manager_(type_manager) {}

  bool Same(const OptionalType& type) const;
  bool operator<(const OptionalType& type) const;
  bool operator>(const OptionalType& type) const;
private:
  utils::IdType type_;
  TypeManager* type_manager_ = nullptr;
};

class ReferenceToType {
public:
  ReferenceToType() = default;
  ReferenceToType(const std::vector<utils::ReferenceType>& references,
                  utils::IdType type,
                  TypeManager* type_manager)
    : references_(references), type_(type), type_manager_(type_manager) {}

  bool Same(const ReferenceToType& type) const;
  bool operator<(const ReferenceToType& type) const;
  bool operator>(const ReferenceToType& type) const;
private:
  std::vector<utils::ReferenceType> references_;
  utils::IdType type_;
  TypeManager* type_manager_ = nullptr;
};

/////////////////////////////

class FunctionType {
public:
  FunctionType() = default;
  FunctionType(const std::vector<utils::IdType>& argument_types,
               utils::IdType return_type,
               TypeManager* type_manager)
    : argument_types_(argument_types), return_type_(return_type), type_manager_(type_manager) {}

  bool Same(const FunctionType& type) const;
  bool operator<(const FunctionType& type) const;
  bool operator>(const FunctionType& type) const;
private:
  std::vector<utils::IdType> argument_types_;
  utils::IdType return_type_;
  TypeManager* type_manager_ = nullptr;
};

class ArrayType {
public:
  ArrayType() = default;
  ArrayType(size_t size,
            utils::IdType  elements_type,
            TypeManager* type_manager)
    : size_(size), elements_type_(elements_type), type_manager_(type_manager) {}

  bool Same(const ArrayType& type) const;
  bool operator<(const ArrayType& type) const;
  bool operator>(const ArrayType& type) const;
private:
  size_t size_; // = 0 for dynamic
  utils::IdType elements_type_;
  TypeManager* type_manager_ = nullptr;
};

class Type {
public:
  template<typename T>
  explicit Type(T&& type) : type_(std::forward(type)) {}

  bool Same(const Type& type) const; // some rule exceptions ??
  bool operator<(const Type& type) const; // TODO: some rule exceptions ??
  bool operator>(const Type& type) const;
private:
  std::variant<AbstractType,
               DefinedType,
               InternalType,
               TupleType,
               VariantType,
               ReferenceToType,
               FunctionType,
               ArrayType> type_;
};

class TypeManager {
public:
  template<typename T>
  utils::IdType AddType(const T&& type);

  template<typename T>
  std::optional<T*> GetType(utils::IdType type_id);

  std::optional<Type*> GetAnyType(utils::IdType type_id);

  void AddTypeRequirement(utils::IdType type, utils::IdType requrement); // TODO
  void EqualTypes(utils::IdType first_type, utils::IdType second_type); // TODO
private:
  std::vector<info::type::Type> types_;
};

} // namespace info::type