mirror of
https://codeberg.org/ProgramSnail/lang.git
synced 2025-12-09 00:18:46 +00:00
type node added (for type deduction)
This commit is contained in:
ProgramSnail
parent
a7c1e3f658
commit
8bce645431
6 changed files with 92 additions and 248 deletions
|
|
@ -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<TypeProxy> get_expression_type() const {
|
||||
return expression_type_;
|
||||
}
|
||||
|
||||
protected:
|
||||
std::optional<TypeProxy> expression_type_;
|
||||
};
|
||||
|
||||
class Expression;
|
||||
class ExpressionStorage;
|
||||
|
||||
|
|
@ -53,9 +69,9 @@ proxy_to_expr_optional(const std::optional<nodes::ExpressionProxy> &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<ExpressionProxy> condition = std::nullopt,
|
||||
std::optional<ExpressionProxy> 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<Case> &&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<Case> &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<ExpressionProxy> 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<ExpressionProxy> &&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<ExpressionProxy> &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<ExpressionProxy> 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<TypeProxy> &&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<std::pair<std::optional<std::string>, 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<std::pair<std::optional<std::string>, 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<std::pair<std::optional<std::string>, ExpressionProxy>>
|
||||
arguments_;
|
||||
};
|
||||
|
||||
class Lambda : public Node {
|
||||
class Lambda : public TypedNode {
|
||||
public:
|
||||
Lambda(Node node, std::vector<Identifier> &&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<Identifier> &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,
|
||||
|
|
|
|||
|
|
@ -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()) {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue