mirror of
https://codeberg.org/ProgramSnail/lang_2023.git
synced 2025-12-26 16:58:45 +00:00
build_visitor fixed, going to test it
This commit is contained in:
ProgramSnail
parent
5bf0c1bf48
commit
c34523bd4f
23 changed files with 45468 additions and 45273 deletions
|
|
@ -159,7 +159,7 @@ void BuildVisitor::Visit(AliasDefinitionStatement* node) {
|
|||
}
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("value");
|
||||
node->value = std::make_unique<ParametrizedType>();
|
||||
node->value = std::make_unique<TypeExpression>();
|
||||
Visit(node->value.get());
|
||||
|
||||
current_node_ = parse_node;
|
||||
|
|
@ -194,7 +194,7 @@ void BuildVisitor::Visit(VariableDefinitionStatement* node) {
|
|||
void BuildVisitor::Visit(FunctionDeclaration* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
node->name = parse_node.ChildByFieldName("name").GetValue();
|
||||
node->name.name = parse_node.ChildByFieldName("name").GetValue();
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
|
|
@ -330,7 +330,7 @@ void BuildVisitor::Visit(SourceStatement& node) {
|
|||
void BuildVisitor::Visit(FunctionDefinition* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
node->name = parse_node.ChildByFieldName("name").GetValue();
|
||||
node->name.name = parse_node.ChildByFieldName("name").GetValue();
|
||||
|
||||
if (parse_node.NthChild(0).GetValue() == "(") {
|
||||
node->modifier = FunctionDefinition::Operator;
|
||||
|
|
@ -395,7 +395,7 @@ void BuildVisitor::Visit(AnyAnnotatedType* node) {
|
|||
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
Visit(node->typeclasses[i]);
|
||||
Visit(node->typeclasses[i].get());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -404,6 +404,87 @@ void BuildVisitor::Visit(AnyAnnotatedType* node) {
|
|||
|
||||
// Flow control -----------------
|
||||
|
||||
void BuildVisitor::Visit(TypeConstructorPatternParameter* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
current_node_ = parse_node.ChildByFieldName("name"),
|
||||
|
||||
node->name.emplace();
|
||||
Visit(&node->name.value());
|
||||
}
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("value"),
|
||||
Visit(node->value);
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TypeConstructorPattern* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
node->constructor = parse_node.ChildByFieldName("constructor").GetValue();
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
node->parameters.resize(child_count - 1);
|
||||
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
Visit(&node->parameters[i]);
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
|
||||
void BuildVisitor::Visit(PatternToken& node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.NthNamedChild(0);
|
||||
|
||||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
if (current_node_type == parser::tokens::ExtendedName) { // optimize ??
|
||||
node = std::make_unique<ExtendedName>();
|
||||
Visit(std::get<std::unique_ptr<ExtendedName>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::Literal) {
|
||||
node = std::make_unique<Literal>();
|
||||
Visit(*std::get<std::unique_ptr<Literal>>(node));
|
||||
} else if (current_node_type == parser::tokens::TypeConstructorPattern) {
|
||||
node = std::make_unique<TypeConstructorPattern>();
|
||||
Visit(std::get<std::unique_ptr<TypeConstructorPattern>>(node).get());
|
||||
} else {
|
||||
// error
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(Pattern& node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.NthNamedChild(0);
|
||||
|
||||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
if (current_node_type == parser::tokens::TypeConstructorPattern) { // optimize ??
|
||||
node = std::make_unique<TypeConstructorPattern>();
|
||||
Visit(std::get<std::unique_ptr<TypeConstructorPattern>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::PatternToken) {
|
||||
node = std::make_unique<PatternToken>();
|
||||
Visit(*std::get<std::unique_ptr<PatternToken>>(node));
|
||||
} else {
|
||||
// error
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(MatchCase* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
|
|
@ -635,9 +716,6 @@ void BuildVisitor::Visit(SubExpression& node) {
|
|||
} else if (current_node_type == parser::tokens::SubExpressionToken) {
|
||||
node = std::make_unique<SubExpressionToken>();
|
||||
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node));
|
||||
} else if (current_node_type == parser::tokens::ArrayExpression) {
|
||||
node = std::make_unique<ArrayExpression>();
|
||||
Visit(std::get<std::unique_ptr<ArrayExpression>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::ReferenceExpression) {
|
||||
node = std::make_unique<ReferenceExpression>();
|
||||
Visit(std::get<std::unique_ptr<ReferenceExpression>>(node).get());
|
||||
|
|
@ -716,6 +794,9 @@ void BuildVisitor::Visit(SuperExpression& node) {
|
|||
} else if (current_node_type == parser::tokens::VariantExpression) {
|
||||
node = std::make_unique<VariantExpression>();
|
||||
Visit(std::get<std::unique_ptr<VariantExpression>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::ArrayExpression) {
|
||||
node = std::make_unique<ArrayExpression>();
|
||||
Visit(std::get<std::unique_ptr<ArrayExpression>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::Expression) {
|
||||
node = std::make_unique<Expression>();
|
||||
Visit(*std::get<std::unique_ptr<Expression>>(node));
|
||||
|
|
@ -823,20 +904,38 @@ void BuildVisitor::Visit(FunctionArgument& node) {
|
|||
void BuildVisitor::Visit(FunctionCallExpression* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
size_t excluded_child_count = 0;
|
||||
|
||||
current_node_ = parse_node.NthNamedChild(0);
|
||||
|
||||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
if (current_node_type == parser::tokens::SubExpressionToken) {
|
||||
node->prefix = std::make_unique<SubExpressionToken>();
|
||||
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node->prefix.value()));
|
||||
++excluded_child_count;
|
||||
} else if (current_node_type == parser::tokens::TypeExpression) {
|
||||
node->prefix = std::make_unique<TypeExpression>();
|
||||
Visit(std::get<std::unique_ptr<TypeExpression>>(node->prefix.value()).get());
|
||||
++excluded_child_count;
|
||||
} else {
|
||||
// no prefix
|
||||
}
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("name");
|
||||
node->name = std::make_unique<NameExpression>();
|
||||
Visit(node->name.get());
|
||||
Visit(&node->name);
|
||||
++excluded_child_count;
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
// if (child_count > 1) { // always true (repeat1)
|
||||
node->arguments.resize(child_count - 1);
|
||||
if (child_count > excluded_child_count) { // always true (repeat1)
|
||||
node->arguments.resize(child_count - excluded_child_count);
|
||||
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
Visit(node->arguments[i]);
|
||||
for (size_t i = 0; i + excluded_child_count < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + excluded_child_count);
|
||||
Visit(node->arguments[i]);
|
||||
}
|
||||
}
|
||||
// }
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
|
@ -880,31 +979,45 @@ void BuildVisitor::Visit(ReturnExpression* node) {
|
|||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TypeConstructorParameter* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
current_node_ = parse_node.ChildByFieldName("name");
|
||||
node->name.emplace();
|
||||
Visit(&node->name.value());
|
||||
|
||||
std::string assignment_modifier = current_node_.NextSibling().GetValue();
|
||||
if (assignment_modifier == "=") {
|
||||
node->asignment_modifier = TypeConstructorParameter::Assign;
|
||||
} else if (assignment_modifier == "<-") {
|
||||
node->asignment_modifier = TypeConstructorParameter::Move;
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("value");
|
||||
Visit(node->value);
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TypeConstructor* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("type");
|
||||
node->type = std::make_unique<ParametrizedType>();
|
||||
Visit(node->type.get());
|
||||
current_node_ = parse_node.ChildByFieldName("constructor");
|
||||
node->constructor = std::make_unique<TypeExpression>();
|
||||
Visit(node->constructor.get());
|
||||
|
||||
size_t parameter_count = (parse_node.NamedChildCount() - 1) / 2;
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
node->parameters.resize(parameter_count);
|
||||
if (child_count > 1) {
|
||||
node->parameters.resize(child_count - 1);
|
||||
|
||||
for (size_t i = 0; i < parameter_count * 2; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
|
||||
if (i % 2 == 0) {
|
||||
Visit(&std::get<0>(node->parameters[i / 2]));
|
||||
|
||||
std::string assignment_modifier = current_node_.NextSibling().GetValue();
|
||||
if (assignment_modifier == "=") {
|
||||
std::get<1>(node->parameters[i / 2]) = TypeConstructor::Assign;
|
||||
} else if (assignment_modifier == "<-") {
|
||||
std::get<1>(node->parameters[i / 2]) = TypeConstructor::Move;
|
||||
}
|
||||
} else {
|
||||
Visit(std::get<2>(node->parameters[i / 2]));
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
Visit(&node->parameters[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -976,23 +1089,10 @@ void BuildVisitor::Visit(NameExpression* node) {
|
|||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
bool namespaces_ended = false;
|
||||
|
||||
node->names.resize(child_count);
|
||||
for (size_t i = 0; i < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i);
|
||||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
if (current_node_type != parser::tokens::TypeSubExpression) {
|
||||
namespaces_ended = true;
|
||||
}
|
||||
|
||||
if (!namespaces_ended) {
|
||||
node->namespaces.emplace_back();
|
||||
Visit(node->namespaces.back());
|
||||
} else {
|
||||
node->expressions.emplace_back();
|
||||
Visit(&node->expressions.back());
|
||||
}
|
||||
Visit(&node->names[i]);
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
|
|
@ -1037,7 +1137,7 @@ void BuildVisitor::Visit(AnnotatedName* node) {
|
|||
|
||||
if (parse_node.NamedChildCount() > 1) {
|
||||
current_node_ = parse_node.ChildByFieldName("type");
|
||||
node->type = std::make_unique<ParametrizedType>();
|
||||
node->type.emplace();
|
||||
Visit(node->type.value());
|
||||
|
||||
current_node_ = parse_node;
|
||||
|
|
@ -1156,27 +1256,6 @@ void BuildVisitor::Visit(VariantType* node) {
|
|||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(ParametrizedType* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("type_expression");
|
||||
node->type_expression = std::make_unique<TypeExpression>();
|
||||
Visit(node->type_expression.get());
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
node->parameters.resize(child_count - 1);
|
||||
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
Visit(node->parameters[i]);
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TypeExpression* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
|
|
@ -1185,7 +1264,7 @@ void BuildVisitor::Visit(TypeExpression* node) {
|
|||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("type");
|
||||
node->type = current_node_.GetValue();
|
||||
Visit(node->type);
|
||||
++excluded_child_count;
|
||||
|
||||
current_node_ = current_node_.NextSibling();
|
||||
|
|
@ -1203,11 +1282,11 @@ void BuildVisitor::Visit(TypeExpression* node) {
|
|||
}
|
||||
|
||||
if (child_count > excluded_child_count) {
|
||||
node->namespaces.resize(child_count - excluded_child_count);
|
||||
node->path.resize(child_count - excluded_child_count);
|
||||
|
||||
for (size_t i = 0; i + excluded_child_count < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i);
|
||||
Visit(node->namespaces[i]);
|
||||
Visit(node->path[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1222,8 +1301,8 @@ void BuildVisitor::Visit(AnyType& node) {
|
|||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
if (current_node_type == parser::tokens::ParametrizedType) {
|
||||
node = std::make_unique<ParametrizedType>();
|
||||
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
|
||||
node = std::make_unique<TypeExpression>();
|
||||
Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::TupleType) {
|
||||
node = std::make_unique<TupleType>();
|
||||
Visit(std::get<std::unique_ptr<TupleType>>(node).get());
|
||||
|
|
@ -1265,16 +1344,36 @@ void BuildVisitor::Visit(ExtendedScopedAnyType* node) {
|
|||
|
||||
// Typeclass
|
||||
|
||||
void BuildVisitor::Visit(TypeclassUsage& node) {
|
||||
void BuildVisitor::Visit(TypeclassExpression* node) {
|
||||
auto parse_node = current_node_;
|
||||
//
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
//
|
||||
// if (child_count > 1) {
|
||||
// node->path.resize(child_count - 1);
|
||||
//
|
||||
// for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
// current_node_ = parse_node.NthNamedChild(i);
|
||||
// Visit(node->path[i]);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
current_node_ = parse_node.ChildByFieldName("typeclass");
|
||||
Visit(node->typeclass);
|
||||
//
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TypeclassSubExpression& node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.NthNamedChild(0);
|
||||
|
||||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
if (current_node_type == parser::tokens::TypeclassExpression) {
|
||||
node = std::make_unique<TypeclassExpression>();
|
||||
Visit(std::get<std::unique_ptr<TypeclassExpression>>(node).get());
|
||||
if (current_node_type == parser::tokens::TypeclassIdentifier) {
|
||||
node = std::make_unique<TypeclassIdentifier>();
|
||||
Visit(std::get<std::unique_ptr<TypeclassIdentifier>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::ParametrizedTypeclass) {
|
||||
node = std::make_unique<ParametrizedTypeclass>();
|
||||
Visit(std::get<std::unique_ptr<ParametrizedTypeclass>>(node).get());
|
||||
|
|
@ -1288,9 +1387,7 @@ void BuildVisitor::Visit(TypeclassUsage& node) {
|
|||
void BuildVisitor::Visit(ParametrizedTypeclass* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.ChildByFieldName("typeclass_expression");
|
||||
node->typeclass_expression = std::make_unique<TypeclassExpression>();
|
||||
Visit(node->typeclass_expression.get());
|
||||
node->typeclass = parse_node.ChildByFieldName("typeclass").GetValue();
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
|
|
@ -1299,54 +1396,16 @@ void BuildVisitor::Visit(ParametrizedTypeclass* node) {
|
|||
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
Visit(node->parameters[i]);
|
||||
node->parameters[i] = std::make_unique<TypeExpression>();
|
||||
Visit(node->parameters[i].get());
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TypeclassExpression* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
node->namespaces.resize(child_count - 1);
|
||||
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i);
|
||||
Visit(node->namespaces[i]);
|
||||
}
|
||||
}
|
||||
|
||||
node->typeclass = parse_node.ChildByFieldName("typeclass").GetValue();
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
// Typeclass & Type -----------------
|
||||
|
||||
void BuildVisitor::Visit(TypeParameter& node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
current_node_ = parse_node.NthNamedChild(0);
|
||||
|
||||
std::string current_node_type = current_node_.GetType();
|
||||
|
||||
if (current_node_type == parser::tokens::TypeExpression) {
|
||||
node = std::make_unique<TypeExpression>();
|
||||
Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
|
||||
} else if (current_node_type == parser::tokens::ParametrizedType) {
|
||||
node = std::make_unique<ParametrizedType>();
|
||||
Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
|
||||
} else {
|
||||
// error
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(TypeSubExpression& node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
|
|
@ -1370,6 +1429,26 @@ void BuildVisitor::Visit(TypeSubExpression& node) {
|
|||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
void BuildVisitor::Visit(ParametrizedType* node) {
|
||||
auto parse_node = current_node_;
|
||||
|
||||
node->type = parse_node.ChildByFieldName("type").GetValue();
|
||||
|
||||
size_t child_count = parse_node.NamedChildCount();
|
||||
|
||||
if (child_count > 1) {
|
||||
node->parameters.resize(child_count - 1);
|
||||
|
||||
for (size_t i = 0; i + 1 < child_count; ++i) {
|
||||
current_node_ = parse_node.NthNamedChild(i + 1);
|
||||
node->parameters[i] = std::make_unique<TypeExpression>();
|
||||
Visit(node->parameters[i].get());
|
||||
}
|
||||
}
|
||||
|
||||
current_node_ = parse_node;
|
||||
}
|
||||
|
||||
// Identifiers, constants, etc. -----------------
|
||||
|
||||
void BuildVisitor::Visit(ExtendedName* node) {
|
||||
|
|
|
|||
|
|
@ -33,8 +33,8 @@ int main(int argc, char** argv) { // TODO, only test version
|
|||
std::make_unique<interpreter::tokens::SourceFile>();
|
||||
|
||||
interpreter::BuildVisitor build_visitor(parse_tree);
|
||||
interpreter::PrintVisitor print_visitor(std::cout);
|
||||
// interpreter::PrintVisitor print_visitor(std::cout);
|
||||
|
||||
build_visitor.VisitSourceFile(source_file.get());
|
||||
print_visitor.VisitSourceFile(source_file.get());
|
||||
// print_visitor.VisitSourceFile(source_file.get());
|
||||
}
|
||||
|
|
|
|||
90118
src/parser.c
90118
src/parser.c
File diff suppressed because it is too large
Load diff
|
|
@ -262,6 +262,16 @@ void PrintVisitor::Visit(AnyAnnotatedType* node) {
|
|||
|
||||
// Flow control -----------------
|
||||
|
||||
void PrintVisitor::Visit(TypeConstructorPatternParameter* node) {
|
||||
out_ << "[TypeConstructorPatternParameter ";
|
||||
if (node->name.has_value()) {
|
||||
Visit(&node->name.value());
|
||||
out_ << " = ";
|
||||
}
|
||||
Visitor::Visit(node->value);
|
||||
out_ << "]";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(TypeConstructorPattern* node) {
|
||||
out_ << "[TypeConstructorPattern ";
|
||||
Visit(&node->constructor);
|
||||
|
|
@ -274,11 +284,7 @@ void PrintVisitor::Visit(TypeConstructorPattern* node) {
|
|||
is_first = false;
|
||||
}
|
||||
out_ << '(';
|
||||
if (parameter.first.has_value()) {
|
||||
Visit(¶meter.first.value());
|
||||
out_ << " = ";
|
||||
}
|
||||
Visitor::Visit(parameter.second);
|
||||
Visit(¶meter);
|
||||
}
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
|
@ -434,18 +440,20 @@ void PrintVisitor::Visit(AccessExpression* node) {
|
|||
// Other Expressions
|
||||
|
||||
void PrintVisitor::Visit(FunctionCallExpression* node) {
|
||||
out_ << "[FunctionCall (";
|
||||
out_ << "[FunctionCall ";
|
||||
|
||||
if (std::holds_alternative<std::unique_ptr<SubExpressionToken>>(node->prefix)) {
|
||||
Visitor::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
|
||||
if (node->prefix.has_value()) {
|
||||
out_ << '(';
|
||||
if (std::holds_alternative<std::unique_ptr<SubExpressionToken>>(node->prefix.value())) {
|
||||
Visitor::Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node->prefix.value()));
|
||||
} else if (std::holds_alternative<std::unique_ptr<TypeExpression>>(node->prefix.value())) {
|
||||
Visit(std::get<std::unique_ptr<TypeExpression>>(node->prefix.value()).get());
|
||||
} else {
|
||||
// error
|
||||
}
|
||||
out_ << ").";
|
||||
}
|
||||
|
||||
out_ << ").";
|
||||
|
||||
Visit(&node->name);
|
||||
|
||||
out_ << "] (";
|
||||
|
|
@ -480,6 +488,23 @@ void PrintVisitor::Visit(ReturnExpression* node) {
|
|||
out_ << ")\n";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(TypeConstructorParameter* node) {
|
||||
out_ << "[TypeConstructorParameter ";
|
||||
if (node->name.has_value()) {
|
||||
Visit(&node->name.value());
|
||||
switch (node->asignment_modifier.value()) {
|
||||
case TypeConstructorParameter::Assign:
|
||||
out_ << " = ";
|
||||
break;
|
||||
case TypeConstructorParameter::Move:
|
||||
out_ << " <- ";
|
||||
break;
|
||||
}
|
||||
}
|
||||
Visitor::Visit(node->value);
|
||||
out_ << "]";
|
||||
}
|
||||
|
||||
void PrintVisitor::Visit(TypeConstructor* node) {
|
||||
out_ << "[TypeConstructor ";
|
||||
Visit(node->constructor.get());
|
||||
|
|
@ -492,18 +517,7 @@ void PrintVisitor::Visit(TypeConstructor* node) {
|
|||
is_first = false;
|
||||
}
|
||||
out_ << '(';
|
||||
if (parameter.first.has_value()) {
|
||||
Visit(¶meter.first.value().first);
|
||||
switch (parameter.first.value().second) {
|
||||
case TypeConstructor::Assign:
|
||||
out_ << " = ";
|
||||
break;
|
||||
case TypeConstructor::Move:
|
||||
out_ << " <- ";
|
||||
break;
|
||||
}
|
||||
}
|
||||
Visitor::Visit(parameter.second);
|
||||
Visit(¶meter);
|
||||
}
|
||||
out_ << ")\n";
|
||||
}
|
||||
|
|
|
|||
|
|
@ -448,13 +448,17 @@ void Visitor::Visit(AnyAnnotatedType* node) {
|
|||
|
||||
// Flow control -----------------
|
||||
|
||||
void Visitor::Visit(TypeConstructorPatternParameter* node) {
|
||||
if (node->name.has_value()) {
|
||||
Visit(&node->name.value());
|
||||
}
|
||||
Visit(node->value);
|
||||
}
|
||||
|
||||
void Visitor::Visit(TypeConstructorPattern* node) {
|
||||
Visit(&node->constructor);
|
||||
for (auto& parameter : node->parameters) {
|
||||
if (parameter.first.has_value()) {
|
||||
Visit(¶meter.first.value());
|
||||
}
|
||||
Visit(parameter.second);
|
||||
Visit(¶meter);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -543,12 +547,14 @@ void Visitor::Visit(AccessExpression* node) {
|
|||
// Other Expressions
|
||||
|
||||
void Visitor::Visit(FunctionCallExpression* node) {
|
||||
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
|
||||
if (node->prefix.has_value()) {
|
||||
if (std::holds_alternative<std::unique_ptr<SubExpressionToken>>(node->prefix.value())) {
|
||||
Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node->prefix.value()));
|
||||
} else if (std::holds_alternative<std::unique_ptr<TypeExpression>>(node->prefix.value())) {
|
||||
Visit(std::get<std::unique_ptr<TypeExpression>>(node->prefix.value()).get());
|
||||
} else {
|
||||
// error
|
||||
}
|
||||
}
|
||||
|
||||
Visit(&node->name);
|
||||
|
|
@ -573,13 +579,17 @@ void Visitor::Visit(ReturnExpression* node) {
|
|||
Visit(node->expression);
|
||||
}
|
||||
|
||||
void Visitor::Visit(TypeConstructorParameter* node) {
|
||||
if (node->name.has_value()) {
|
||||
Visit(&node->name.value());
|
||||
}
|
||||
Visit(node->value);
|
||||
}
|
||||
|
||||
void Visitor::Visit(TypeConstructor* node) {
|
||||
Visit(node->constructor.get());
|
||||
for (auto& parameter : node->parameters) {
|
||||
if (parameter.first.has_value()) {
|
||||
Visit(¶meter.first.value().first);
|
||||
}
|
||||
Visit(parameter.second);
|
||||
Visit(¶meter);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue