From 8bce645431e50dba03535cdcb03e7bac87b900d5 Mon Sep 17 00:00:00 2001 From: ProgramSnail Date: Tue, 8 Aug 2023 20:21:48 +0300 Subject: [PATCH] type node added (for type deduction) --- CMakeLists.txt | 1 - include/nodes/expression_nodes.hpp | 119 ++++++++++-------- include/nodes/type_nodes.hpp | 22 ++++ include/types.hpp | 188 ----------------------------- src/builders/type_builders.cpp | 1 - src/types.cpp | 9 -- 6 files changed, 92 insertions(+), 248 deletions(-) delete mode 100644 include/types.hpp delete mode 100644 src/types.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 748812d..26ac34f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -43,7 +43,6 @@ set( add_executable(lang src/main.cpp src/name_tree.cpp - src/types.cpp ${NODES} ${BUILDERS} diff --git a/include/nodes/expression_nodes.hpp b/include/nodes/expression_nodes.hpp index bf8343c..a9866d6 100644 --- a/include/nodes/expression_nodes.hpp +++ b/include/nodes/expression_nodes.hpp @@ -9,6 +9,22 @@ namespace nodes { +class TypedNode : public Node { +public: + TypedNode(Node node) : Node(node) {} + + void set_expression_type(TypeProxy expression_type) { + expression_type_ = expression_type; + } + + std::optional get_expression_type() const { + return expression_type_; + } + +protected: + std::optional expression_type_; +}; + class Expression; class ExpressionStorage; @@ -53,9 +69,9 @@ proxy_to_expr_optional(const std::optional &proxy) { // --- flow control -class Match : public Node { +class Match : public TypedNode { public: - class Case : public Node { + class Case : public TypedNode { public: enum CaseType { PATTERN_VALUE, @@ -65,7 +81,7 @@ public: Case(Node node, CaseType case_type, ExpressionProxy value, std::optional condition = std::nullopt, std::optional expression = std::nullopt) - : Node(node), case_type_(case_type), value_(value), + : TypedNode(node), case_type_(case_type), value_(value), condition_(condition), expression_(expression) {} CaseType case_type() const { return case_type_; } @@ -98,10 +114,10 @@ public: }; Match(Node node, ExpressionProxy value, std::vector &&cases) - : Node(node), value_(value), cases_(std::move(cases)) {} + : TypedNode(node), value_(value), cases_(std::move(cases)) {} Match(Node node, ExpressionProxy value, const std::vector &cases) - : Node(node), value_(value), cases_(cases) {} + : TypedNode(node), value_(value), cases_(cases) {} Expression *get_value() { return value_.get(); } @@ -154,7 +170,7 @@ private: std::optional else_case_; }; -class Loop : public Node { +class Loop : public TypedNode { public: enum LoopType { LOOP, @@ -164,20 +180,20 @@ public: // LOOP Loop(Node node, ExpressionProxy expression) - : Node(node), type_(LOOP), expression_(expression) {} + : TypedNode(node), loop_type_(LOOP), expression_(expression) {} // WHILE Loop(Node node, ExpressionProxy condition, ExpressionProxy expression) - : Node(node), type_(WHILE), expression_(expression), + : TypedNode(node), loop_type_(WHILE), expression_(expression), condition_(condition) {} // FOR Loop(Node node, ExpressionProxy variable, ExpressionProxy interval, ExpressionProxy expression) - : Node(node), type_(FOR), expression_(expression), variable_(variable), - interval_(interval) {} + : TypedNode(node), loop_type_(FOR), expression_(expression), + variable_(variable), interval_(interval) {} - LoopType get_type() const { return type_; } + LoopType get_type() const { return loop_type_; } Expression *get_expression() { return expression_.get(); } @@ -208,7 +224,7 @@ public: } private: - LoopType type_; + LoopType loop_type_; ExpressionProxy expression_; @@ -219,7 +235,7 @@ private: // --- containers -class Container : public Node { +class Container : public TypedNode { public: enum ContainerType { BLOCK, @@ -228,13 +244,14 @@ public: Container(Node node, ContainerType type, std::vector &&expressions) - : Node(node), type_(type), expressions_(std::move(expressions)) {} + : TypedNode(node), container_type_(type), + expressions_(std::move(expressions)) {} Container(Node node, ContainerType type, const std::vector &expressions) - : Node(node), type_(type), expressions_(expressions) {} + : TypedNode(node), container_type_(type), expressions_(expressions) {} - ContainerType get_type() const { return type_; } + ContainerType get_type() const { return container_type_; } size_t expressions_size() const { return expressions_.size(); } @@ -245,7 +262,7 @@ public: } private: - ContainerType type_; + ContainerType container_type_; std::vector expressions_; }; @@ -260,21 +277,21 @@ public: }; Return(Node node, ReturnType type, ExpressionProxy expression) - : Node(node), type_(type), expression_(expression) {} + : Node(node), return_type_(type), expression_(expression) {} - ReturnType get_type() const { return type_; } + ReturnType get_type() const { return return_type_; } Expression *get_expression() { return expression_.get(); } const Expression *get_expression() const { return expression_.get(); } private: - ReturnType type_; + ReturnType return_type_; ExpressionProxy expression_; }; -class NameDefinition : public Node { +class NameDefinition : public TypedNode { public: enum Modifier { LET, // % @@ -282,10 +299,10 @@ public: }; NameDefinition(Node node, Modifier modifier, Identifier &&name) - : Node(node), modifier_(modifier), name_(std::move(name)) {} + : TypedNode(node), modifier_(modifier), name_(std::move(name)) {} NameDefinition(Node node, Modifier modifier, const Identifier &name) - : Node(node), modifier_(modifier), name_(name) {} + : TypedNode(node), modifier_(modifier), name_(name) {} Modifier get_modifier() const { return modifier_; } @@ -299,7 +316,7 @@ private: Identifier name_; }; -class Access : public Node { +class Access : public TypedNode { public: enum AccessType { ARRAY, @@ -308,9 +325,9 @@ public: Access(Node node, AccessType type, ExpressionProxy value, ExpressionProxy index) - : Node(node), type_(type), value_(value), index_(index) {} + : TypedNode(node), access_type_(type), value_(value), index_(index) {} - AccessType get_type() const { return type_; } + AccessType get_type() const { return access_type_; } Expression *get_value() { return value_.get(); } @@ -321,31 +338,32 @@ public: const Expression *get_index() const { return index_.get(); } private: - AccessType type_; + AccessType access_type_; ExpressionProxy value_; ExpressionProxy index_; }; -class LoopControl : public Node { +class LoopControl : public TypedNode { public: enum LoopControlType { BREAK, CONTINUE, }; - LoopControl(Node node, LoopControlType type) : Node(node), type_(type) {} + LoopControl(Node node, LoopControlType type) + : TypedNode(node), loop_control_type_(type) {} - LoopControlType get_type() const { return type_; } + LoopControlType get_type() const { return loop_control_type_; } private: - LoopControlType type_; + LoopControlType loop_control_type_; }; -class ModifierExpression : public Node { +class ModifierExpression : public TypedNode { public: ModifierExpression(Node node, Modifier modifier, ExpressionProxy expression) - : Node(node), modifier_(modifier), expression_(expression) {} + : TypedNode(node), modifier_(modifier), expression_(expression) {} Modifier get_modifier() const { return modifier_; } @@ -361,12 +379,13 @@ private: // --- other -class NameExpression : public Node { +class NameExpression : public TypedNode { public: NameExpression(Node node, Identifier &&name) - : Node(node), name_(std::move(name)) {} + : TypedNode(node), name_(std::move(name)) {} - NameExpression(Node node, const Identifier &name) : Node(node), name_(name) {} + NameExpression(Node node, const Identifier &name) + : TypedNode(node), name_(name) {} NameExpression( Node node, Identifier &&name, @@ -374,9 +393,9 @@ public: &&arguments, std::optional &&prefix, bool is_point_call = false, bool is_operator_call = false) - : Node(node), name_(std::move(name)), arguments_(std::move(arguments)), - prefix_(std::move(prefix)), is_point_call_(is_point_call), - is_operator_call_(is_operator_call) {} + : TypedNode(node), name_(std::move(name)), + arguments_(std::move(arguments)), prefix_(std::move(prefix)), + is_point_call_(is_point_call), is_operator_call_(is_operator_call) {} Identifier *get_name() { return &name_; } @@ -435,23 +454,24 @@ private: bool is_operator_call_ = false; // ... operator ... }; -class Constructor : public Node { +class Constructor : public TypedNode { public: Constructor( Node node, TypeProxy type, std::vector, ExpressionProxy>> &&arguments) - : Node(node), type_(type), arguments_(std::move(arguments)) {} + : TypedNode(node), constructor_type_(type), + arguments_(std::move(arguments)) {} Constructor( Node node, TypeProxy type, const std::vector, ExpressionProxy>> &arguments) - : Node(node), type_(type), arguments_(arguments) {} + : TypedNode(node), constructor_type_(type), arguments_(arguments) {} - Type *get_type() { return type_.get(); } + Type *get_type() { return constructor_type_.get(); } - const Type *get_type() const { return type_.get(); } + const Type *get_type() const { return constructor_type_.get(); } size_t arguments_size() const { return arguments_.size(); } @@ -478,20 +498,21 @@ public: } private: - TypeProxy type_; + TypeProxy constructor_type_; std::vector, ExpressionProxy>> arguments_; }; -class Lambda : public Node { +class Lambda : public TypedNode { public: Lambda(Node node, std::vector &&arguments, ExpressionProxy expression) - : Node(node), arguments_(std::move(arguments)), expression_(expression) {} + : TypedNode(node), arguments_(std::move(arguments)), + expression_(expression) {} Lambda(Node node, const std::vector &arguments, ExpressionProxy expression) - : Node(node), arguments_(arguments), expression_(expression) {} + : TypedNode(node), arguments_(arguments), expression_(expression) {} size_t arguments_size() const { return arguments_.size(); } @@ -550,7 +571,7 @@ private: // --- modifiers Return, NameDefinition, - // TupleAccess - Access with nmber Literal index + // TupleAccess - Access with number Literal index Access, LoopControl, // Reference or SuffixExpression is ModifierExpression ModifierExpression, diff --git a/include/nodes/type_nodes.hpp b/include/nodes/type_nodes.hpp index 3fe36ba..773ae0b 100644 --- a/include/nodes/type_nodes.hpp +++ b/include/nodes/type_nodes.hpp @@ -119,6 +119,28 @@ public: // + bool operator<(const Type &other_type) const { + if (name_ != other_type.name_) { + return *name_.get() < *other_type.name_.get(); + } + + if (is_on_heap_ != other_type.is_on_heap_) { + return is_on_heap_ < other_type.is_on_heap_; + } + + if (parameters_.size() != other_type.parameters_.size()) { + return parameters_.size() < other_type.parameters_.size(); + } + + for (size_t i = 0; i < parameters_.size(); ++i) { + if (*parameters_[i].get() != *other_type.parameters_[i].get()) { + return false; + } + } + + return true; + } + bool operator==(const Type &other_type) const { if (name_ != other_type.name_ || is_on_heap_ != other_type.is_on_heap_ || parameters_.size() != other_type.parameters_.size()) { diff --git a/include/types.hpp b/include/types.hpp deleted file mode 100644 index dbc012d..0000000 --- a/include/types.hpp +++ /dev/null @@ -1,188 +0,0 @@ -#pragma once - -#include "basic_nodes.hpp" -#include "name_tree.hpp" -#include "statement_nodes.hpp" - -#include -#include - -namespace types { - -class Type; -class TypeStorage; - -class TypeProxy { - friend TypeStorage; - -public: - Type *get(); - - const Type *get() const; - -private: - TypeProxy(TypeStorage &type_storage, size_t id) - : type_storage_(&type_storage), id_(id) {} - -private: - TypeStorage *type_storage_; - size_t id_; -}; - -class Defined { -public: - Defined(names::StatementProxy definition) - : definition_(definition) {} - - nodes::TypeDefinition *get_definition() { return definition_.get(); } - - const nodes::TypeDefinition *get_definition() const { - return definition_.get(); - } - -private: - names::StatementProxy definition_; -}; - -class Abstract { -public: - Abstract(std::optional name, - std::vector typeclasses) - : name_(name), typeclasses_(typeclasses) {} - - // - - std::optional get_name() { - if (name_.has_value()) { - return &name_.value(); - } - return std::nullopt; - } - - std::optional get_name() const { - if (name_.has_value()) { - return &name_.value(); - } - return std::nullopt; - } - - // - - size_t typeclasses_size() const { return typeclasses_.size(); } - - std::string *get_typeclass(size_t id) { return &typeclasses_.at(id); } - - const std::string *get_typeclass(size_t id) const { - return &typeclasses_.at(id); - } - -private: - std::optional name_; - std::vector typeclasses_; -}; - -class Modified { -public: - Modified(nodes::Modifier modifier, TypeProxy type) - : modifier_(modifier), type_(type) {} - - nodes::Modifier get_modifier() const { return modifier_; } - - Type *get_type() { return type_.get(); } - - const Type *get_type() const { return type_.get(); } - - const TypeProxy &get_type_proxy() const { return type_; } - -private: - nodes::Modifier modifier_; - TypeProxy type_; -}; - -class Container { -public: - enum ContainerType { - OR, - AND, - }; - - Container(ContainerType type, std::vector &&fields) - : type_(type), fields_(std::move(fields)) {} - - Container(ContainerType type, const std::vector &fields) - : type_(type), fields_(std::move(fields)) {} - - // - - ContainerType get_type() const { return type_; } - - // - - size_t fields_size() const { return fields_.size(); } - - Type *get_field(size_t id) { return fields_.at(id).get(); } - - const Type *get_field(size_t id) const { return fields_.at(id).get(); } - - const TypeProxy &get_field_proxy(size_t id) const { return fields_.at(id); } - -private: - ContainerType type_; - std::vector fields_; // or constructors -}; - -class Type { -public: - Type(const Type &) = default; - Type(Type &&) = default; - Type &operator=(const Type &) = default; - - template - explicit Type(T &&type) : type_(std::forward(type)) {} - - template std::optional get() { - if (std::holds_alternative(type_)) { - return &std::get(type_); - } - return std::nullopt; - } - - template std::optional get() const { - if (std::holds_alternative(type_)) { - return &std::get(type_); - } - return std::nullopt; - } - - auto get_any() { return &type_; } - - auto get_any() const { return &type_; } - -private: - std::variant type_; -}; - -class TypeStorage { - friend TypeProxy; - -public: - TypeProxy add_type(const Type &type) { - storage_.push_back(type); - return TypeProxy(*this, storage_.size() - 1); - } - - TypeProxy add_type(Type &&type) { - storage_.push_back(std::move(type)); - return TypeProxy(*this, storage_.size() - 1); - } - -private: - Type *get_type(size_t id) { return &storage_.at(id); } - - const Type *get_type(size_t id) const { return &storage_.at(id); } - -private: - std::vector storage_; -}; - -}; // namespace types diff --git a/src/builders/type_builders.cpp b/src/builders/type_builders.cpp index 72ec187..64ff8f5 100644 --- a/src/builders/type_builders.cpp +++ b/src/builders/type_builders.cpp @@ -5,7 +5,6 @@ #include "error_handling.hpp" #include "tokens.hpp" #include "type_nodes.hpp" -#include "types.hpp" namespace builders { diff --git a/src/types.cpp b/src/types.cpp deleted file mode 100644 index fc513c7..0000000 --- a/src/types.cpp +++ /dev/null @@ -1,9 +0,0 @@ -#include "types.hpp" - -namespace types { - -Type *TypeProxy::get() { return type_storage_->get_type(id_); } - -const Type *TypeProxy::get() const { return type_storage_->get_type(id_); } - -} // namespace types