st/lang_2023
1
0
Fork 0
mirror of https://codeberg.org/ProgramSnail/lang_2023.git synced 2025-12-06 15:08:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

visitor base fixed

Browse source
This commit is contained in:
ProgramSnail 2023-04-25 14:52:38 +03:00
parent 2ff2f3af12
commit c6c2a00e04
3 changed files with 89 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

15
include/interpreter_tree.hpp
View file

@ -369,7 +369,7 @@ struct TypeDefinition {
struct AnnotatedAbstractType {
AbstractTypeIdentifier type;
std::vector<TypeclassExpression> typeclasses;
std::vector<std::unique_ptr<TypeclassExpression>> typeclasses;
utils::IdType type_graph_id_;
};
@ -459,7 +459,8 @@ struct AccessExpression {
// Other Expressions -----------------
struct FunctionCallExpression {
std::unique_ptr<std::variant<SubExpressionToken, TypeExpression>> prefix;
std::variant<std::unique_ptr<SubExpressionToken>,
std::unique_ptr<TypeExpression>> prefix;
ExtendedName name;
std::vector<FunctionArgument> arguments;
};
@ -547,22 +548,22 @@ struct ExtendedScopedAnyType {
// Typeclass -----------------
struct TypeclassExpression {
std::vector<TypeSubExpression> namespaces;
std::vector<TypeSubExpression> types;
TypeclassSubExpression typeclass;
utils::IdType type_id_;
};
struct ParametrizedTypeclass {
TypeclassIdentifier typeclass_expression;
std::vector<TypeExpression> parameters;
TypeclassIdentifier typeclass;
std::vector<std::unique_ptr<TypeExpression>> parameters;
};
// Typeclass & Type -----------------
struct ParametrizedType {
AnyTypeIdentifier type_expression;
std::vector<TypeExpression> parameters;
AnyTypeIdentifier type;
std::vector<std::unique_ptr<TypeExpression>> parameters;
};
// ----------------- Comments [IGNORE] -----------------

11
include/visitor.hpp
View file

@ -45,6 +45,7 @@ protected:
// Flow control -----------------
virtual void Visit(TypeConstructorPattern* node);
virtual void Visit(MatchCase* node);
virtual void Visit(Match* node);
virtual void Visit(Condition* node);
@ -53,6 +54,8 @@ protected:
virtual void Visit(ForLoop* node);
virtual void Visit(LoopLoop* node);
virtual void Visit(PatternToken& node); // variant
virtual void Visit(Pattern& node); // variant
virtual void Visit(FlowControl& node); // variant
// Statements, expressions, blocks, etc. -----------------
@ -107,7 +110,6 @@ protected:
virtual void Visit(FunctionType* node);
virtual void Visit(TupleType* node);
virtual void Visit(VariantType* node);
virtual void Visit(ParametrizedType* node);
virtual void Visit(TypeExpression* node);
virtual void Visit(AnyType& node); // variant
@ -116,14 +118,15 @@ protected:
// Typeclass
virtual void Visit(ParametrizedTypeclass* node);
virtual void Visit(TypeclassExpression* node);
virtual void Visit(ParametrizedTypeclass* node);
virtual void Visit(TypeclassUsage& node); // variant
virtual void Visit(TypeclassSubExpression& node); // variant
// Typeclass & Type
virtual void Visit(TypeParameter& node); // variant
virtual void Visit(ParametrizedType* node);
virtual void Visit(TypeSubExpression& node); // variant
// Identifiers, constants, etc. -----------------

120
src/visitor.cpp
View file

@ -39,6 +39,37 @@ void Visitor::Visit(SourceStatement& node) {
// Flow control -----------------
void Visitor::Visit(PatternToken& node) {
switch (node.index()) {
case 0:
Visit(std::get<std::unique_ptr<ExtendedName>>(node).get());
break;
case 1:
Visit(*std::get<std::unique_ptr<Literal>>(node).get());
break;
case 2:
Visit(std::get<std::unique_ptr<TypeConstructorPattern>>(node).get());
break;
default:
// error
break;
}
}
void Visitor::Visit(Pattern& node) {
switch (node.index()) {
case 0:
Visit(std::get<std::unique_ptr<TypeConstructorPattern>>(node).get());
break;
case 1:
Visit(*std::get<std::unique_ptr<PatternToken>>(node));
break;
default:
// error
break;
}
}
void Visitor::Visit(FlowControl& node) {
switch (node.index()) {
case 0:
@ -121,9 +152,6 @@ void Visitor::Visit(SubExpression& node) {
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node));
break;
case 3:
Visit(std::get<std::unique_ptr<ArrayExpression>>(node).get());
break;
case 4:
Visit(std::get<std::unique_ptr<ReferenceExpression>>(node).get());
break;
default:
@ -184,6 +212,9 @@ void Visitor::Visit(SuperExpression& node) {
Visit(std::get<std::unique_ptr<VariantExpression>>(node).get());
break;
case 3:
Visit(std::get<std::unique_ptr<ArrayExpression>>(node).get());
break;
case 4:
Visit(*std::get<std::unique_ptr<Expression>>(node));
break;
default:
@ -234,7 +265,7 @@ void Visitor::Visit(AnyName& node) {
void Visitor::Visit(AnyType& node) {
switch (node.index()) {
case 0:
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
break;
case 1:
Visit(std::get<std::unique_ptr<TupleType>>(node).get());
@ -253,10 +284,10 @@ void Visitor::Visit(AnyType& node) {
// Typeclass
void Visitor::Visit(TypeclassUsage& node) {
void Visitor::Visit(TypeclassSubExpression& node) {
switch (node.index()) {
case 0:
Visit(std::get<std::unique_ptr<TypeclassExpression>>(node).get());
Visit(std::get<std::unique_ptr<TypeclassIdentifier>>(node).get());
break;
case 1:
Visit(std::get<std::unique_ptr<ParametrizedTypeclass>>(node).get());
@ -269,20 +300,6 @@ void Visitor::Visit(TypeclassUsage& node) {
// Typeclass & Type
void Visitor::Visit(TypeParameter& node) {
switch (node.index()) {
case 0:
Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
break;
case 1:
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
break;
default:
// error
break;
}
}
void Visitor::Visit(TypeSubExpression& node) {
switch (node.index()) {
case 0:
@ -425,12 +442,15 @@ void Visitor::Visit(TypeDefinition* node) {
void Visitor::Visit(AnyAnnotatedType* node) {
Visit(&node->type);
for (auto& typeclass : node->typeclasses) {
Visit(typeclass);
Visit(typeclass.get());
}
}
// Flow control -----------------
void Visitor::Visit(TypeConstructorPattern* node) {
}
void Visitor::Visit(MatchCase* node) {
Visit(node->value);
if (node->condition.has_value()) {
@ -516,7 +536,15 @@ void Visitor::Visit(AccessExpression* node) {
// Other Expressions
void Visitor::Visit(FunctionCallExpression* node) {
Visit(node->name.get());
if (std::holds_alternative<std::unique_ptr<SubExpressionToken>>(node->prefix)) {
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node->prefix));
} else if (std::holds_alternative<std::unique_ptr<TypeExpression>>(node->prefix)) {
Visit(std::get<std::unique_ptr<TypeExpression>>(node->prefix).get());
} else {
// error
}
Visit(&node->name);
for (auto& argument : node->arguments) {
Visit(argument);
}
@ -539,10 +567,12 @@ void Visitor::Visit(ReturnExpression* node) {
}
void Visitor::Visit(TypeConstructor* node) {
Visit(node->type.get());
Visit(node->constructor.get());
for (auto& parameter : node->parameters) {
Visit(&std::get<0>(parameter));
Visit(std::get<2>(parameter));
if (parameter.first.has_value()) {
Visit(&parameter.first.value().first);
}
Visit(parameter.second);
}
}
@ -565,11 +595,8 @@ void Visitor::Visit(ArrayExpression* node) {
// Name
void Visitor::Visit(NameExpression* node) {
for (auto& variable_namespace : node->namespaces) {
Visit(variable_namespace);
}
for (size_t i = 0; i < node->expressions.size(); ++i) {
Visit(&node->expressions[i]);
for (auto& name : node->names) {
Visit(&name);
}
}
@ -629,18 +656,10 @@ void Visitor::Visit(VariantType* node) {
}
}
void Visitor::Visit(ParametrizedType* node) {
Visit(node->type_expression.get());
for (auto& parameter : node->parameters) {
Visit(parameter);
}
}
void Visitor::Visit(TypeExpression* node) {
for (auto& type_namespace : node->namespaces) {
Visit(type_namespace);
for (auto& type : node->types) {
Visit(type);
}
Visit(&node->type);
}
void Visitor::Visit(ExtendedScopedAnyType* node) {
@ -649,18 +668,27 @@ void Visitor::Visit(ExtendedScopedAnyType* node) {
// Typeclass
void Visitor::Visit(TypeclassExpression* node) {
for (auto& type : node->types) {
Visit(type);
}
Visit(node->typeclass);
}
void Visitor::Visit(ParametrizedTypeclass* node) {
Visit(node->typeclass_expression.get());
Visit(&node->typeclass);
for (auto& parameter : node->parameters) {
Visit(parameter);
Visit(parameter.get());
}
}
void Visitor::Visit(TypeclassExpression* node) {
for (auto& typeclass_namespace : node->namespaces) {
Visit(typeclass_namespace);
// Typeclass & Type -----------------
void Visitor::Visit(ParametrizedType* node) {
Visit(&node->type);
for (auto& parameter : node->parameters) {
Visit(parameter.get());
}
Visit(&node->typeclass);
}
// Identifiers, constants, etc. -----------------