st/lang_2023
1
0
Fork 0
mirror of https://codeberg.org/ProgramSnail/lang_2023.git synced 2026-01-25 13:07:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

type structs -> type classes

Browse source
This commit is contained in:
ProgramSnail 2023-05-02 15:18:08 +03:00
parent a512a92f92
commit 648f78afa3
14 changed files with 638 additions and 383 deletions
Download patch file Download diff file Expand all files Collapse all files

205
include/types.hpp
View file

@ -4,68 +4,195 @@
#include <string>
#include <variant>
#include <memory>
#include <unordered_set>
// for clangd
#include "utils.hpp"
namespace info::type {
// // Temporary frozen, TODO
// struct AbstractType {
// utils::IdType graph_id;
// std::vector<utils::IdType> paramaters;
// };
// TODO: move in constructors
// TODO: check, if defined type is variant, etc.
struct DefinedType {
utils::IdType type_id; // in defined types
utils::IdType type; // in types manager, created using context types
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,
Int,
String,
Char,
Bool,
Unit,
Float = 0,
Int = 1,
String = 2,
Char = 3,
Bool = 4,
Unit = 5,
};
struct TupleType {
std::optional<std::string> type;
std::vector<std::pair<std::optional<std::string>, utils::IdType>> fields;
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;
};
struct VariantType {
std::optional<std::string> type;
std::vector<TupleType> constructors;
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_;
};
struct OptionalType {
std::optional<utils::IdType> type; // Can be empty (Some or None)
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;
};
struct ReferenceToType {
std::vector<utils::ReferenceType> references;
utils::IdType type;
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;
};
struct FunctionType {
std::vector<utils::IdType> argument_types;
utils::IdType return_type;
/////////////////////////////
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;
};
struct ArrayType {
size_t size; // ?? = 0 for dynamic ??
std::optional<utils::IdType> elements_type;
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;
};
using Type = std::variant<DefinedType,
InternalType,
TupleType,
VariantType,
ReferenceToType,
FunctionType,
ArrayType>;
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