debug

src/print_visitor.cpp

@@ -9,7 +9,7 @@ void PrintVisitor::Visit(Node* node) {
 
 // Sources -----------------
 void PrintVisitor::Visit(SourceFile* node) {
-  out_ << "<SourceFile>\n\n";
+  out_ << "(SourceFile\n\n";
   for (auto& statement : node->statements) {
     if (std::holds_alternative<Partition>(statement)) {
       Visit(&std::get<Partition>(statement));
@@ -19,21 +19,21 @@ void PrintVisitor::Visit(SourceFile* node) {
       // error
     }
   }
-  out_ << "\n<SourceFile/>";
+  out_ << "\nSourceFile)\n";
 }
 
 void PrintVisitor::Visit(Sources* node) {
-  out_ << "<Sources>\n\n";
+  out_ << "(Sources\n\n";
   for (auto& statement : node->statements) {
     Visitor::Visit(statement);
   }
-  out_ << "\n</Sources>";
+  out_ << "\n)\n";
 }
 
 // Namespaces, partittions -----------------
 
 void PrintVisitor::Visit(Partition* node) {
-  out_ << "<Partition> ";
+  out_ << "(Partition ";
   switch (node->type) {
     case Partition::Test:
       out_ << "TEST";
@@ -56,11 +56,11 @@ void PrintVisitor::Visit(Partition* node) {
   }
   out_ << " {\n";
   Visit(node->scope.get());
-  out_ << "} </Partition>\n";
+  out_ << "} )\n";
 }
 
 void PrintVisitor::Visit(Namespace* node) {
-  out_ << "<Namespace> ";
+  out_ << "(Namespace ";
   if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
     if (node->is_const) {
       out_ << "const ";
@@ -75,13 +75,13 @@ void PrintVisitor::Visit(Namespace* node) {
   }
   out_ << "{\n";
   Visit(node->scope.get());
-  out_ << "} </Namespace>\n";
+  out_ << "} )\n";
 }
 
 // Definitions -----------------
 
 void PrintVisitor::Visit(ImportStatement* node) {
-  out_ << "<Import> \"" << node->module_name << "\" ";
+  out_ << "(Import \"" << node->module_name << "\" ";
   if (node->symbols.size() > 0) {
     out_ << '\n';
   }
@@ -89,35 +89,35 @@ void PrintVisitor::Visit(ImportStatement* node) {
     Visitor::Visit(symbol);
     out_ << '\n';
   }
-  out_ << "</Import>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(UsageDefinition* node) {
-  out_ << "<Usage> ";
+  out_ << "(Usage ";
   Visit(&node->name);
   out_ << " = ";
   Visit(node->import_statement.get());
-  out_ << "</Usage>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(AliasDefinition* node) {
-  out_ << "<Alias> ";
+  out_ << "(Alias ";
   Visit(node->type.get());
   out_ << " = ";
   Visit(node->value.get());
-  out_ << "</Alias>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(VariableDefinition* node) {
-  out_ << "<Variable> " << (node->is_const ? "const" : "var") << ' ';
+  out_ << "(Variable " << (node->is_const ? "const" : "var") << ' ';
   Visit(&node->name);
   out_ << " = ";
   Visitor::Visit(node->value);
-  out_ << "</Variable>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(FunctionDeclaration* node) {
-  out_ << "<FunctionDeclaration> ";
+  out_ << "(FunctionDeclaration ";
   Visit(&node->name);
   out_ << "\n";
   for (auto& parameter : node->parameters) {
@@ -127,35 +127,35 @@ void PrintVisitor::Visit(FunctionDeclaration* node) {
   for (auto& argument_type : node->argument_types) {
     Visitor::Visit(argument_type);
   }
-  out_ << "</FunctionDeclaration>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(FunctionDefinition* node) {
-  out_ << "<Function> ";
+  out_ << "(Function ";
   Visit(node->name.get());
   out_ << " = ";
   Visitor::Visit(node->value);
-  out_ << "</Function>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(AliasTypeDefinition* node) {
-  out_ << "<AliasType> ";
+  out_ << "(AliasType ";
   Visit(node->type.get());
   out_ << " = ";
   Visit(node->value.get());
-  out_ << "</AliasType>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(TypeDefinition* node) {
-  out_ << "<Type> ";
+  out_ << "(Type ";
   Visit(node->type.get());
   out_ << " = ";
   Visitor::Visit(node->value);
-  out_ << "</Type>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(TypeclassDefinition* node) {
-  out_ << "<Typeclass> ";
+  out_ << "(Typeclass ";
   Visit(node->typeclass.get());
   if (node->requirements.size() > 0) {
     out_ << " : \n";
@@ -164,13 +164,13 @@ void PrintVisitor::Visit(TypeclassDefinition* node) {
     out_ << "& ";
     Visit(requirement.get());
   }
-  out_ << "</Typeclass>\n";
+  out_ << ")\n";
 }
 
 // Definition parts
 
 void PrintVisitor::Visit(DefinedName* node) {
-  out_ << "<DefinedName> ";
+  out_ << "(DefinedName ";
   Visit(&node->name);
   if (node->parameters.size() > 0) {
     out_ << "\n";
@@ -184,11 +184,11 @@ void PrintVisitor::Visit(DefinedName* node) {
   for (auto& argument : node->arguments) {
     Visit(argument.get());
   }
-  out_ << "</DefinedName>\n";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(DefinedAnnotatedName* node) {
-  out_ << "<DefinedAnnotatedName> ";
+  out_ << "(DefinedAnnotatedName ";
   Visit(&node->name);
   out_ << " : ";
   if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->type)) {
@@ -198,11 +198,11 @@ void PrintVisitor::Visit(DefinedAnnotatedName* node) {
   } else {
     // no annotation
   }
-  out_ << " </DefinedAnnotatedName>";
+  out_ << " )";
 }
 
 void PrintVisitor::Visit(DefinedType* node) {
-  out_ << "<DefinedType> ";
+  out_ << "(DefinedType ";
   Visit(node->type.get());
   if (node->parameters.size() > 0) {
     out_ << "\n";
@@ -216,11 +216,11 @@ void PrintVisitor::Visit(DefinedType* node) {
   for (auto& argument : node->arguments) {
     Visit(argument.get());
   }
-  out_ << "</DefinedType>\n";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(DefinedTypeclass* node) {
-  out_ << "<DefinedTypeclass> ";
+  out_ << "(DefinedTypeclass ";
   Visit(node->typeclass.get());
   if (node->parameters.size() > 0) {
     out_ << "\n";
@@ -234,33 +234,33 @@ void PrintVisitor::Visit(DefinedTypeclass* node) {
   for (auto& argument : node->arguments) {
     Visit(argument.get());
   }
-  out_ << "</DefinedTypeclass>\n";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(DefinitionParameter* node) {
-  out_ << "<DefinitionParameter> " << (node->typeclasses.size() > 0 ? "(" : "");
+  out_ << "(DefinitionParameter " << (node->typeclasses.size() > 0 ? "(" : "");
   Visit(&node->type);
   out_ << ' ';
   for (auto& typeclass : node->typeclasses) {
     Visit(typeclass.get());
   }
-  out_ << "</DefinitionParamater>\n";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(DefinitionArgument* node) {
-  out_ << "<DefinitionArgument> " << (node->types.size() > 0 ? "(" : "");
+  out_ << "(DefinitionArgument " << (node->types.size() > 0 ? "(" : "");
   Visit(&node->name);
   out_ << ' ';
   for (auto& type : node->types) {
     Visit(type.get());
   }
-  out_ << "</DefinitionArgument>\n";
+  out_ << ")";
 }
 
 // Flow control -----------------
 
 void PrintVisitor::Visit(MatchCase* node) {
-  out_ << "<MatchCase> | ";
+  out_ << "(MatchCase | ";
   Visitor::Visit(node->value);
   if (node->condition.has_value()) {
     out_ << " ? ";
@@ -270,21 +270,21 @@ void PrintVisitor::Visit(MatchCase* node) {
     out_ << " -> ";
     Visitor::Visit(node->statement.value());
   }
-  out_ << "</MatchCase>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(Match* node) {
-  out_ << "<Match> ";
+  out_ << "(Match ";
   Visitor::Visit(node->value);
   out_ << " with\n";
   for (auto& match_case : node->matches) {
     Visit(&match_case);
   }
-  out_ << "</Match>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(Condition* node) {
-  out_ << "<If> ";
+  out_ << "(If ";
   Visitor::Visit(node->conditions[0]);
   out_ << " then\n";
   Visitor::Visit(node->statements[0]);
@@ -301,63 +301,63 @@ void PrintVisitor::Visit(Condition* node) {
     Visitor::Visit(node->statements[node->conditions.size()]);
     out_ << '\n';
   }
-  out_ << "</If>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(DoWhileLoop* node) {
-  out_ << "<DoWhile>\n";
+  out_ << "(DoWhile\n";
   Visitor::Visit(node->statement);
   out_ << "\nwhile\n";
   Visitor::Visit(node->condition);
-  out_ << "\n</DoWhile>\n";
+  out_ << "\n)\n";
 }
 
 void PrintVisitor::Visit(WhileLoop* node) {
-  out_ << "<While>\n";
+  out_ << "(While\n";
   Visitor::Visit(node->statement);
   out_ << "\ndo\n";
   Visitor::Visit(node->condition);
-  out_ << "\n</While>\n";
+  out_ << "\n)\n";
 }
 void PrintVisitor::Visit(ForLoop* node) {
-  out_ << "<For>\n";
+  out_ << "(For\n";
   Visitor::Visit(node->variable);
   out_ << "\nin\n";
   Visitor::Visit(node->interval);
   out_ << "\ndo\n";
   Visitor::Visit(node->statement);
-  out_ << "</For>\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(LoopLoop* node) {
-  out_ << "<Loop>\n";
+  out_ << "(Loop\n";
   Visitor::Visit(node->statement);
-  out_ << "<\n/Loop>\n";
+  out_ << "\nLoop)\n";
 }
 
 // Statements, expressions, blocks, etc. -----------------
 
 void PrintVisitor::Visit(Block* node) {
-  out_ << "<Block> {\n";
+  out_ << "(Block {\n";
   for (auto& statement : node->statements) {
     Visitor::Visit(statement);
   }
-  out_ << "} </Block>\n";
+  out_ << "} )\n";
 }
 
 void PrintVisitor::Visit(ScopedStatement* node) {
-  out_ << "<Scoped> ( ";
+  out_ << "(Scoped ( ";
   Visitor::Visit(node->statement);
-  out_ << " ) </Scoped>";
+  out_ << " ) )\n";
 }
 
 void PrintVisitor::Visit(LoopControlExpression& node) { // enum
   switch (node) {
     case LoopControlExpression::Break:
-      out_ << "<Break/>\n";
+      out_ << "(Break/>\n";
       break;
     case LoopControlExpression::Continue:
-      out_ << "<Continue/>\n";
+      out_ << "(Continue/>\n";
       break;
   }
 }
@@ -365,66 +365,66 @@ void PrintVisitor::Visit(LoopControlExpression& node) { // enum
 // Operators
 
 void PrintVisitor::Visit(BinaryOperatorExpression* node) {
-  out_ << "<BinaryOperator> ";
+  out_ << "(BinaryOperator ";
   Visitor::Visit(node->left_expression);
   out_ << ' ';
   Visit(&node->operator_name);
   out_ << ' ';
   Visitor::Visit(node->right_expression);
-  out_ << " </BinaryOperator>";
+  out_ << " )";
 }
 
 void PrintVisitor::Visit(UnaryOperatorExpression* node) {
-  out_ << "<UnaryOperator> ";
+  out_ << "(UnaryOperator ";
   Visit(&node->operator_name);
   out_ << ' ';
   Visitor::Visit(node->expression);
-  out_ << " </UnaryOperator>";
+  out_ << " )";
 }
 
 // Simple Expressions
 
 void PrintVisitor::Visit(FunctionCallExpression* node) {
-  out_ << "<FunctionCall> ";
+  out_ << "(FunctionCall ";
   Visit(node->name.get());
   out_ << ' ';
   for (auto& argument : node->arguments) {
     Visitor::Visit(argument);
     out_ << ' ';
   }
-  out_ << "</FunctionCall>";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(TupleExpression* node) {
-  out_ << "<TupleExpression> ";
+  out_ << "(TupleExpression ";
   out_ << ' ';
   for (auto& expression : node->expressions) {
     out_ << "& ";
     Visitor::Visit(expression);
   }
-  out_ << " </TupleExpression>";
+  out_ << " )\n";
 }
 
 void PrintVisitor::Visit(VariantExpression* node) {
-  out_ << "<VariantExpression> ";
+  out_ << "(VariantExpression ";
   out_ << ' ';
   for (auto& expression : node->expressions) {
     out_ << "& ";
     Visitor::Visit(expression);
   }
-  out_ << " </VariantExpression>";
+  out_ << " )\n";
 }
 
 void PrintVisitor::Visit(ReturnExpression* node) {
-  out_ << "<Return> ";
+  out_ << "(Return ";
   Visitor::Visit(node->expression);
-  out_ << " </Return>";
+  out_ << " )\n";
 }
 
 // Lambda
 
 void PrintVisitor::Visit(LambdaFunction* node) {
-  out_ << "<LambdaFunction> \\ ";
+  out_ << "(LambdaFunction \\ ";
   for (auto& parameter : node->parameters) {
     Visit(parameter.get());
   }
@@ -436,73 +436,73 @@ void PrintVisitor::Visit(LambdaFunction* node) {
   }
   out_ << " -> ";
   Visitor::Visit(node->expression);
-  out_ << " </LambdaFunction>";
+  out_ << " )\n";
 }
 
 // Name
 
 void PrintVisitor::Visit(NameSuperExpression* node) {
-  out_ << "<NameSuperExpression> ";
+  out_ << "(NameSuperExpression ";
   for (auto& variable_namespace : node->namespaces) {
     Visitor::Visit(variable_namespace);
     out_ << '.';
   }
-  for (int i = 0; i < node->expressions.size(); ++i) {
+  for (size_t i = 0; i < node->expressions.size(); ++i) {
     Visitor::Visit(node->expressions[i]);
     if (i + 1 < node->expressions.size()) {
       out_ << '.';
     }
   }
-  out_ << "</NameSupperExpression>\n";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(NameExpression* node) {
-  out_ << "<NameExpression> ";
+  out_ << "(NameExpression ";
   for (auto& variable_namespace : node->namespaces) {
     Visitor::Visit(variable_namespace);
     out_ << '.';
   }
-  for (int i = 0; i < node->names.size(); ++i) {
+  for (size_t i = 0; i < node->names.size(); ++i) {
     Visit(&node->names[i]);
     if (i + 1 < node->names.size()) {
       out_ << '.';
     }
   }
-  out_ << "</NameExpression>\n";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(TupleName* node) {
-  out_ << "<TupleName> ";
+  out_ << "(TupleName ";
   for (auto& name : node->names) {
     out_ << '&';
     Visit(name.get());
   }
-  out_ << "</TupleName>\n";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(VariantName* node) {
-  out_ << "<VariantName> ";
+  out_ << "(VariantName ";
   for (auto& name : node->names) {
     out_ << '|';
     Visit(name.get());
   }
-  out_ << "</VariantName>\n";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(AnnotatedName* node) {
-  out_ << "<AnnotatedName> ";
+  out_ << "(AnnotatedName ";
   Visit(&node->name);
   if (node->type.has_value()) {
     out_ << " : ";
     Visit(node->type.value().get());
   }
-  out_ << " </AnnotatedName>";
+  out_ << " )";
 }
 
 // Type
 
 void PrintVisitor::Visit(TypeConstructor* node) {
-  out_ << "<TypeConstructor> ";
+  out_ << "(TypeConstructor ";
   Visit(node->type.get());
   out_ << '\n';
   for (auto& parameter : node->parameters) {
@@ -511,13 +511,13 @@ void PrintVisitor::Visit(TypeConstructor* node) {
     Visitor::Visit(parameter.second);
     out_ << '\n';
   }
-  out_ << "</TypeConstructor>\n";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(TupleType* node) {
-  out_ << "<TupleType> ";
+  out_ << "(TupleType ";
   if (node->type.has_value()) {
-    Visit(&node->type.value()); // optional
+    Visit(&node->type.value());
   }
   out_ << ' ';
   for (auto& entity : node->entities) {
@@ -528,11 +528,11 @@ void PrintVisitor::Visit(TupleType* node) {
     }
     Visitor::Visit(entity.second);
   }
-  out_ << "</TupleType>";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(VariantType* node) {
-  out_ << "<VariantType> ";
+  out_ << "(VariantType ";
   if (node->type.has_value()) {
     Visit(&node->type.value());
   }
@@ -540,18 +540,18 @@ void PrintVisitor::Visit(VariantType* node) {
   for (auto& constructor : node->constructors) {
     out_ << "| ";
     if (std::holds_alternative<TypeIdentifierDefinition>(constructor)) {
-    Visit(&std::get<TypeIdentifierDefinition>(constructor));
+      Visit(&std::get<TypeIdentifierDefinition>(constructor));
     } else if (std::holds_alternative<std::unique_ptr<TupleType>>(constructor)) {
       Visit(std::get<std::unique_ptr<TupleType>>(constructor).get());
     } else {
       // error
     }
   }
-  out_ << "</VariantType>";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(AnnotatedType* node) {
-  out_ << "<AnnotatedType> ";
+  out_ << "(AnnotatedType ";
   Visit(node->type_expression.get());
   if (node->annotations.size() > 0) {
     out_ << " :";
@@ -560,33 +560,33 @@ void PrintVisitor::Visit(AnnotatedType* node) {
     out_ << " ";
     Visit(annotation.get());
   }
-  out_ << "</AnnotatedType>";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(ParametrizedType* node) {
-  out_ << "<ParametrizedType> ";
+  out_ << "(ParametrizedType ";
   Visit(node->type_expression.get());
   for (auto& paramater : node->parameters) {
     out_ << ' ';
     Visitor::Visit(paramater);
   }
-  out_ << " </ParamtrizedType>";
+  out_ << " )";
 }
 
 void PrintVisitor::Visit(TypeExpression* node) {
-  out_ << "<TypeExpression> ";
+  out_ << "(TypeExpression ";
   for (auto& type_namespace : node->namespaces) {
     Visitor::Visit(type_namespace);
     out_ << '.';
   }
   Visit(&node->type);
-  out_ << " </TypeExpression>";
+  out_ << " )";
 }
 
 // Typeclass
 
 void PrintVisitor::Visit(AnnotatedTypeclass* node) {
-  out_ << "<AnnotatedTypeclass> ";
+  out_ << "(AnnotatedTypeclass ";
   Visit(node->typeclass_expression.get());
   if (node->annotations.size() > 0) {
     out_ << " :";
@@ -595,49 +595,49 @@ void PrintVisitor::Visit(AnnotatedTypeclass* node) {
     out_ << " ";
     Visit(annotation.get());
   }
-  out_ << "</AnnotatedTypeclass>";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(ParametrizedTypeclass* node) {
-  out_ << "<ParametrizedTypeclass> ";
+  out_ << "(ParametrizedTypeclass ";
   Visit(node->typeclass_expression.get());
   for (auto& paramater : node->parameters) {
     out_ << ' ';
     Visitor::Visit(paramater);
   }
-  out_ << " </ParamtrizedTypeclass>";
+  out_ << " )";
 }
 
 void PrintVisitor::Visit(TypeclassExpression* node) {
-  out_ << "<TypeclassExpression> ";
+  out_ << "(TypeclassExpression ";
   for (auto& typeclass_namespace : node->namespaces) {
     Visitor::Visit(typeclass_namespace);
     out_ << '.';
   }
   Visit(&node->typeclass);
-  out_ << " </TypeclassExpression>";
+  out_ << " )";
 }
 
 // Identifiers, constants, etc. -----------------
 
 void PrintVisitor::Visit(AnyIdentifier* node) { // std::string
-  out_ << "<Identifier " << *node << " />";
+  out_ << "(Identifier " << *node << " )";
 }
 
 void PrintVisitor::Visit(FloatNumberLiteral* node) {
-  out_ << "<Identifier " << node->value << " />";
+  out_ << "(FloatNumber " << node->value << " )";
 }
 
 void PrintVisitor::Visit(NumberLiteral* node) {
-  out_ << "<Number " << node->value << " />";
+  out_ << "(Number " << node->value << " )";
 }
 
 void PrintVisitor::Visit(StringLiteral* node) {
-  out_ << "<String " << node->value << " />";
+  out_ << "(String " << node->value << " )";
 }
 
 void PrintVisitor::Visit(CharLiteral* node) {
-  out_ << "<Char " << node->value << " />";
+  out_ << "(Char " << node->value << " )";
 }
 
 } // namespace interpreter