st/lang_2023
1
0
Fork 0
mirror of https://codeberg.org/ProgramSnail/lang_2023.git synced 2025-12-26 16:58: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

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. -----------------