part of print_visitor + interpreter_tree fixes

include/interpreter_tree.hpp

@@ -3,6 +3,7 @@
 #include <string>
 #include <vector>
 #include <variant>
+#include <optional>
 #include <memory>
 
 // for clangd
@@ -47,16 +48,16 @@ struct TypeDefinition;
 struct TypeclassDefinition;
 
 using SourceStatement = std::variant<
-  ImportStatement,
+  std::unique_ptr<ImportStatement>,
-  UsageDefinition,
+  std::unique_ptr<UsageDefinition>,
-  AliasDefinition,
+  std::unique_ptr<AliasDefinition>,
-  VariableDefinition, // ??
+  std::unique_ptr<VariableDefinition>, // ??
-  FunctionDeclaration,
+  std::unique_ptr<FunctionDeclaration>,
-  FunctionDefinition,
+  std::unique_ptr<FunctionDefinition>,
-  AliasTypeDefinition,
+  std::unique_ptr<AliasTypeDefinition>,
-  TypeDefinition,
+  std::unique_ptr<TypeDefinition>,
-  TypeclassDefinition,
+  std::unique_ptr<TypeclassDefinition>,
-  Namespace>;
+  std::unique_ptr<Namespace>>;
 
 // Definition parts
 
@@ -65,10 +66,10 @@ struct TupleType;
 struct VariantType;
 struct ParametrizedTypeclass;
 using FunctionDeclarationType = std::variant<
-  ParametrizedType,
+  std::unique_ptr<ParametrizedType>,
-  TupleType,
+  std::unique_ptr<TupleType>,
-  VariantType,
+  std::unique_ptr<VariantType>,
-  ParametrizedTypeclass>;
+  std::unique_ptr<ParametrizedTypeclass>>;
 
 struct DefinedName;
 struct DefinedAnnotatedName;
@@ -87,11 +88,12 @@ struct ForLoop;
 struct LoopLoop;
 
 using FlowControl = std::variant<
-  Match,
+  std::unique_ptr<Match>,
-  Condition,
+  std::unique_ptr<Condition>,
-  WhileLoop,
+  std::unique_ptr<DoWhileLoop>,
-  ForLoop,
+  std::unique_ptr<WhileLoop>,
-  LoopLoop>;
+  std::unique_ptr<ForLoop>,
+  std::unique_ptr<LoopLoop>>;
 
 // Statements, expressions, blocks, etc. -----------------
 
@@ -102,9 +104,14 @@ struct Block;
 struct NameExpression;
 struct ScopedStatement;
 
+enum class LoopControlExpression {
+    Break,
+    Continue,
+};
+
 using SubExpressionToken = std::variant<
-  NameExpression,
+  std::unique_ptr<NameExpression>,
-  ScopedStatement>;
+  std::unique_ptr<ScopedStatement>>;
 
 //
 
@@ -112,23 +119,18 @@ struct FunctionCallExpression;
 struct BinaryOperatorExpression;
 
 using SubExpression = std::variant<
-  FunctionCallExpression,
+  std::unique_ptr<FunctionCallExpression>,
-  BinaryOperatorExpression,
+  std::unique_ptr<BinaryOperatorExpression>,
-  SubExpressionToken>;
+  std::unique_ptr<SubExpressionToken>>;
 
 //
 
 struct ReturnExpression;
 
-enum class LoopControlExpression {
-    Break,
-    Continue,
-};
-
 using PrefixedExpression = std::variant<
-  ReturnExpression,
+  std::unique_ptr<ReturnExpression>,
-  LoopControlExpression,
+  std::unique_ptr<LoopControlExpression>,
-  Block>;
+  std::unique_ptr<Block>>;
 
 //
 
@@ -137,11 +139,11 @@ struct TypeConstructor;
 struct UnaryOperatorExpression;
 
 using Expression = std::variant<
-  LambdaFunction,
+  std::unique_ptr<LambdaFunction>,
-  TypeConstructor,
+  std::unique_ptr<TypeConstructor>,
-  PrefixedExpression,
+  std::unique_ptr<PrefixedExpression>,
-  UnaryOperatorExpression,
+  std::unique_ptr<UnaryOperatorExpression>,
-  SubExpression>;
+  std::unique_ptr<SubExpression>>;
 
 //
 
@@ -149,10 +151,10 @@ struct TupleExpression;
 struct VariantExpression;
 
 using SuperExpression = std::variant<
-  FlowControl,
+  std::unique_ptr<FlowControl>,
-  TupleExpression,
+  std::unique_ptr<TupleExpression>,
-  VariantExpression,
+  std::unique_ptr<VariantExpression>,
-  Expression>;
+  std::unique_ptr<Expression>>;
 
 //
 
@@ -183,9 +185,9 @@ struct VariantName;
 struct AnnotatedName;
 
 using AnyName = std::variant<
-  AnnotatedName,
+  std::unique_ptr<AnnotatedName>,
-  TupleName,
+  std::unique_ptr<TupleName>,
-  VariantName>;
+  std::unique_ptr<VariantName>>;
 
 // Type
 
@@ -198,9 +200,9 @@ struct VariantType;
 struct VariantType;
 
 using AnyType = std::variant<
-  ParametrizedType,
+  std::unique_ptr<ParametrizedType>,
-  TupleType,
+  std::unique_ptr<TupleType>,
-  VariantType>;
+  std::unique_ptr<VariantType>>;
 
 // // TypeIdentifierDefinition <-> some '.' + TypeIdentifier
 using TypeIdentifierDefinition = std::string;
@@ -211,8 +213,8 @@ struct ParametrizedType;
 struct TypeExpression;
 
 using TypeSubExpression = std::variant<
-  AnyTypeIdentifier,
+  std::unique_ptr<AnyTypeIdentifier>,
-  ParametrizedType>;
+  std::unique_ptr<ParametrizedType>>;
 
 // Typeclass
 
@@ -229,17 +231,17 @@ struct StringLiteral;
 struct CharLiteral;
 
 using Literal = std::variant<
-  FloatNumberLiteral,
+  std::unique_ptr<FloatNumberLiteral>,
-  NumberLiteral,
+  std::unique_ptr<NumberLiteral>,
-  StringLiteral,
+  std::unique_ptr<StringLiteral>,
-  CharLiteral>;
+  std::unique_ptr<CharLiteral>>;
 
 //
 
 using NameSubSuperExpression = std::variant<
-  NameIdentifier,
+  std::unique_ptr<NameIdentifier>,
-  Literal,
+  std::unique_ptr<Literal>,
-  SuperExpression>;
+  std::unique_ptr<SuperExpression>>;
 
 // ----------------- Sources -----------------
 
@@ -248,13 +250,13 @@ struct SourceFile : public Node {
 };
 
 struct Sources : public Node {
-  std::vector<SourceStatement> statemets;
+  std::vector<SourceStatement> statements;
 };
 
 // ----------------- Namespaces, partittions -----------------
 
 struct Partition : public Node {
-  enum class PartitionType {
+  enum PartitionType {
     Test,
     Interface,
     Core,
@@ -268,7 +270,9 @@ struct Partition : public Node {
 };
 
 struct Namespace : public Node {
-  std::unique_ptr<std::variant<DefinedAnnotatedName, DefinedType>> name;
+  std::variant<
+    std::unique_ptr<DefinedAnnotatedName>,
+    std::unique_ptr<DefinedType>> name;
   // TODO add const / var specification
   std::unique_ptr<Sources> scope;
 };
@@ -280,41 +284,42 @@ struct TypeExpression;
 struct NameExpression;
 
 using ImportSymbol = std::variant<
-  TypeclassExpression,
+  std::unique_ptr<TypeclassExpression>,
-  TypeExpression,
+  std::unique_ptr<TypeExpression>,
-  NameExpression>;
+  std::unique_ptr<NameExpression>>;
 
 //
 
 struct ImportStatement : public Node {
   std::string module_name;
-  std::vector<std::unique_ptr<ImportSymbol>> symbols;
+  std::vector<ImportSymbol> symbols;
 };
 
 struct UsageDefinition : public Node {
-  TypeIdentifier module_identifier;
+  TypeIdentifier name; // rename ??
   std::unique_ptr<ImportStatement> import_statement;
 };
 
 struct AliasDefinition : public Node {
-  std::unique_ptr<DefinedType> name;
+  std::unique_ptr<DefinedType> type;
   std::unique_ptr<ParametrizedType> value;
 };
 
 struct VariableDefinition : public Node {
   bool is_const; // default value ??
   NameIdentifier name;
-  std::unique_ptr<SuperExpression> value;
+  SuperExpression value;
 };
 
 struct FunctionDeclaration : public Node {
   NameIdentifier name;
-  std::vector<std::unique_ptr<FunctionDeclarationType>> argument_types;
+  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
+  std::vector<FunctionDeclarationType> argument_types;
 };
 
-struct FunctionDefintion : public Node {
+struct FunctionDefinition : public Node {
   std::unique_ptr<DefinedName> name;
-  std::unique_ptr<SuperExpression> value;
+  SuperExpression value;
 };
 
 struct AliasTypeDefinition : public Node {
@@ -324,7 +329,7 @@ struct AliasTypeDefinition : public Node {
 
 struct TypeDefinition : public Node {
   std::unique_ptr<DefinedType> name;
-  std::unique_ptr<AnyType> value;
+  AnyType value;
 };
 
 struct TypeclassDefinition : public Node {
@@ -343,7 +348,9 @@ struct DefinedName : public Node {
 
 struct DefinedAnnotatedName : public Node {
   NameIdentifier name;
-  std::unique_ptr<std::variant<DefinedType, DefinedTypeclass>> type;
+  std::variant<
+    std::unique_ptr<DefinedType>,
+    std::unique_ptr<DefinedTypeclass>> type;
 };
 
 struct DefinedType : public Node {
@@ -359,7 +366,7 @@ struct DefinedTypeclass : public Node {
 };
 
 struct DefinitionParameter : public Node {
-  AbstractTypeIdentifier abstract_type;
+  AbstractTypeIdentifier type;
   std::vector<std::unique_ptr<ParametrizedTypeclass>> typeclasses;
 };
 
@@ -371,74 +378,76 @@ struct DefinitionArgument : public Node {
 // ----------------- Flow control -----------------
 
 struct MatchCase {
-  std::unique_ptr<Expression> value;
+  Expression value;
-  std::unique_ptr<Expression> condition;
+  std::optional<Expression> condition;
-  std::unique_ptr<Expression> statement;
+  std::optional<Expression> statement;
 };
 
 struct Match : public Node {
-  std::unique_ptr<Expression> value;
+  Expression value;
   std::vector<MatchCase> matches;
 };
 
 struct Condition : public Node {
-  std::vector<std::unique_ptr<Expression>> conditions; // if, elif
+  std::vector<Expression> conditions; // if, elif
-  std::vector<std::unique_ptr<Expression>> stetemets; // if, elif, else
+  std::vector<Expression> statements; // if, elif, else
 };
 
 struct DoWhileLoop : public Node {
-  std::unique_ptr<Expression> consition;
+  Expression condition;
-  std::unique_ptr<Expression> statement;
+  Expression statement;
 };
 
 struct WhileLoop : public Node {
-  std::unique_ptr<Expression> condition;
+  Expression condition;
-  std::unique_ptr<Expression> statement;
+  Expression statement;
 };
 
 struct ForLoop : public Node {
-  std::unique_ptr<AnyName> variable;
+  AnyName variable;
-  std::unique_ptr<Expression> interval;
+  Expression interval;
-  std::unique_ptr<Expression> statement;
+  Expression statement;
 };
 
 struct LoopLoop : public Node {
-  std::unique_ptr<Expression> statement;
+  Expression statement;
 };
 
 // ----------------- Statements, expressions, blocks, etc. -----------------
 
 using BlockStatement = std::variant<
-  Expression,
+  std::unique_ptr<Expression>,
-  AliasDefinition,
+  std::unique_ptr<AliasDefinition>,
-  VariableDefinition,
+  std::unique_ptr<VariableDefinition>,
-  FlowControl,
+  std::unique_ptr<FlowControl>,
-  PrefixedExpression>;
+  std::unique_ptr<PrefixedExpression>>;
 
 struct Block : public Node {
-  std::vector<std::unique_ptr<BlockStatement>> statements;
+  std::vector<BlockStatement> statements;
 };
 
 struct ScopedStatement : public Node {
-  std::unique_ptr<SuperExpression> statement;
+  SuperExpression statement;
 };
 
 // Operators -----------------
 
 struct BinaryOperatorExpression : public Node {
   OperatorIdentifier operator_name;
-  std::unique_ptr<SubExpression> left_expression;
+  SubExpression left_expression;
-  std::unique_ptr<SubExpression> right_expression;
+  SubExpression right_expression;
 };
 
 struct UnaryOperatorExpression : public Node { // TODO fix prescendence
   OperatorIdentifier operator_name;
-  std::unique_ptr<Expression> expression;
+  Expression expression;
 };
 
 // Simple Expressions -----------------
 
-using FunctionArgument = std::variant<SubExpressionToken, TypeSubExpression>;
+using FunctionArgument = std::variant<
+  std::unique_ptr<SubExpressionToken>,
+  std::unique_ptr<TypeSubExpression>>;
 
 struct FunctionCallExpression : public Node {
   std::unique_ptr<NameSuperExpression> name;
@@ -514,7 +523,9 @@ struct AnnotatedType : public Node {
   std::vector<std::unique_ptr<ParametrizedTypeclass>> annotations;
 };
 
-using TypeParameter = std::variant<ParametrizedType, Expression>;
+using TypeParameter = std::variant<
+  std::unique_ptr<ParametrizedType>,
+  std::unique_ptr<Expression>>;
 
 struct ParametrizedType : public Node {
   std::unique_ptr<TypeExpression> type_expression;

include/print_visitor.hpp

@@ -0,0 +1,114 @@
+#pragma once
+
+#include <ostream>
+
+// for clangd
+#include "visitor.hpp"
+
+namespace interpreter {
+
+class PrintVisitor : public Visitor {
+public:
+  PrintVisitor(std::ostream& out) : out_(out) {}
+
+  // -----------------
+
+  void Visit(Node* node) override;
+
+  // Sources -----------------
+
+  void Visit(SourceFile* node) override;
+  void Visit(Sources* node) override;
+
+  // Namespaces, partittions -----------------
+
+  void Visit(Partition* node) override;
+  void Visit(Namespace* node) override;
+
+  // Definitions -----------------
+
+  void Visit(ImportStatement* node) override;
+  void Visit(UsageDefinition* node) override;
+  void Visit(AliasDefinition* node) override;
+  void Visit(VariableDefinition* node) override;
+  void Visit(FunctionDeclaration* node) override;
+  void Visit(FunctionDefinition* node) override;
+  void Visit(AliasTypeDefinition* node) override;
+  void Visit(TypeDefinition* node) override;
+  void Visit(TypeclassDefinition* node) override;
+
+  // Definition parts
+
+  void Visit(DefinedName* node) override;
+  void Visit(DefinedAnnotatedName* node) override;
+  void Visit(DefinedType* node) override;
+  void Visit(DefinedTypeclass* node) override;
+  void Visit(DefinitionParameter* node) override;
+  void Visit(DefinitionArgument* node) override;
+
+  // Flow control -----------------
+
+  void Visit(Match* node) override;
+  void Visit(Condition* node) override;
+  void Visit(DoWhileLoop* node) override;
+  void Visit(WhileLoop* node) override;
+  void Visit(ForLoop* node) override;
+  void Visit(LoopLoop* node) override;
+
+  // Statements, expressions, blocks, etc. -----------------
+
+  void Visit(Block* node) override;
+  void Visit(ScopedStatement* node) override;
+
+  // Operators
+
+  void Visit(BinaryOperatorExpression* node) override;
+  void Visit(UnaryOperatorExpression* node) override;
+
+  // Simple Expressions
+
+  void Visit(FunctionCallExpression* node) override;
+  void Visit(TupleExpression* node) override;
+  void Visit(VariantExpression* node) override;
+  void Visit(ReturnExpression* node) override;
+
+  // Lambda
+
+  void Visit(LambdaFunction* node) override;
+
+  // Name
+
+  void Visit(NameSuperExpression* node) override;
+  void Visit(NameExpression* node) override;
+  void Visit(TupleName* node) override;
+  void Visit(VariantName* node) override;
+  void Visit(AnnotatedName* node) override;
+
+  // Type
+
+  void Visit(TypeConstructor* node) override;
+  void Visit(TupleType* node) override;
+  void Visit(VariantType* node) override;
+  void Visit(AnnotatedType* node) override;
+  void Visit(ParametrizedType* node) override;
+  void Visit(TypeExpression* node) override;
+
+  // Typeclass
+
+  void Visit(AnnotatedTypeclass* node) override;
+  void Visit(ParametrizedTypeclass* node) override;
+  void Visit(TypeclassExpression* node) override;
+
+  // Identifiers, constants, etc. -----------------
+
+  void Visit(AnyIdentifier* node) override; // std::string
+
+  void Visit(FloatNumberLiteral* node) override;
+  void Visit(NumberLiteral* node) override;
+  void Visit(StringLiteral* node) override;
+  void Visit(CharLiteral* node) override;
+private:
+  std::ostream& out_;
+};
+
+} // namespace interpreter

include/visitor.hpp

@@ -9,98 +9,136 @@ using namespace tokens;
 
 class Visitor {
 public:
-  virtual void Visit(Node* node) = 0; // ??
+  virtual void VisitSourceFile(SourceFile* source_file) {
+    Visit(source_file);
+  }
+
+  // -----------------
+
+  virtual void Visit(Node* node) {}
 
   // Sources -----------------
 
-  virtual void Visit(SourceFile* node) = 0;
+  virtual void Visit(SourceFile* node) {}
-  virtual void Visit(Sources* node) = 0;
+  virtual void Visit(Sources* node) {}
 
   // Namespaces, partittions -----------------
 
-  virtual void Visit(Partition* node) = 0;
+  virtual void Visit(Partition* node) {}
-  virtual void Visit(Namespace* node) = 0;
+  virtual void Visit(Namespace* node) {}
 
   // Definitions -----------------
 
-  virtual void Visit(ImportStatement* node) = 0;
+  virtual void Visit(ImportStatement* node) {}
-  virtual void Visit(UsageDefinition* node) = 0;
+  virtual void Visit(UsageDefinition* node) {}
-  virtual void Visit(AliasDefinition* node) = 0;
+  virtual void Visit(AliasDefinition* node) {}
-  virtual void Visit(VariableDefinition* node) = 0;
+  virtual void Visit(VariableDefinition* node) {}
-  virtual void Visit(FunctionDeclaration* node) = 0;
+  virtual void Visit(FunctionDeclaration* node) {}
-  virtual void Visit(FunctionDefinition* node) = 0;
+  virtual void Visit(FunctionDefinition* node) {}
-  virtual void Visit(AliasTypeDefinition* node) = 0;
+  virtual void Visit(AliasTypeDefinition* node) {}
-  virtual void Visit(TypeDefinition* node) = 0;
+  virtual void Visit(TypeDefinition* node) {}
-  virtual void Visit(TypeclassDefinition* node) = 0;
+  virtual void Visit(TypeclassDefinition* node) {}
+
+  void Visit(SourceStatement& node); // variant
+  void Visit(ImportSymbol& node); // variant
 
   // Definition parts
 
-  virtual void Visit(DefinedName* node) = 0;
+  virtual void Visit(DefinedName* node) {}
-  virtual void Visit(DefinedAnnotatedName* node) = 0;
+  virtual void Visit(DefinedAnnotatedName* node) {}
-  virtual void Visit(DefinedType* node) = 0;
+  virtual void Visit(DefinedType* node) {}
-  virtual void Visit(DefinedTypeclass* node) = 0;
+  virtual void Visit(DefinedTypeclass* node) {}
-  virtual void Visit(DefinitionParameter* node) = 0;
+  virtual void Visit(DefinitionParameter* node) {}
-  virtual void Visit(DefinitionArgument* node) = 0;
+  virtual void Visit(DefinitionArgument* node) {}
+
+  void Visit(FunctionDeclarationType& node); // variant
 
   // Flow control -----------------
 
-  virtual void Visit(Match* node) = 0;
+  virtual void Visit(Match* node) {}
-  virtual void Visit(Condition* node) = 0;
+  virtual void Visit(Condition* node) {}
-  virtual void Visit(DoWhileLoop* node) = 0;
+  virtual void Visit(DoWhileLoop* node) {}
-  virtual void Visit(WhileLoop* node) = 0;
+  virtual void Visit(WhileLoop* node) {}
-  virtual void Visit(ForLoop* node) = 0;
+  virtual void Visit(ForLoop* node) {}
-  virtual void Visit(LoopLoop* node) = 0;
+  virtual void Visit(LoopLoop* node) {}
+
+  void Visit(FlowControl& node); // variant
 
   // Statements, expressions, blocks, etc. -----------------
 
-  virtual void Visit(Block* node) = 0;
+  virtual void Visit(Block* node) {}
-  virtual void Visit(ScopedStatement* node) = 0;
+  virtual void Visit(ScopedStatement* node) {}
+
+  virtual void Visit(LoopControlExpression& node) {} // enum
+
+  void Visit(SubExpressionToken& node); // variant
+  void Visit(SubExpression& node); // variant
+  void Visit(PrefixedExpression& node); // variant
+  void Visit(Expression& node); // variant
+  void Visit(SuperExpression& node); // variant
+
+  void Visit(BlockStatement& node); // variant
 
   // Operators
 
-  virtual void Visit(BinaryOperatorExpression* node) = 0;
+  virtual void Visit(BinaryOperatorExpression* node) {}
-  virtual void Visit(UnaryOperatorExpression* node) = 0;
+  virtual void Visit(UnaryOperatorExpression* node) {}
 
   // Simple Expressions
 
-  virtual void Visit(FunctionCallExpression* node) = 0;
+  virtual void Visit(FunctionCallExpression* node) {}
-  virtual void Visit(TupleExpression* node) = 0;
+  virtual void Visit(TupleExpression* node) {}
-  virtual void Visit(VariantExpression* node) = 0;
+  virtual void Visit(VariantExpression* node) {}
-  virtual void Visit(ReturnExpression* node) = 0;
+  virtual void Visit(ReturnExpression* node) {}
+
+  void Visit(FunctionArgument& node); // variant
 
   // Lambda
 
-  virtual void Visit(LambdaFunction* node) = 0;
+  virtual void Visit(LambdaFunction* node) {}
 
   // Name
 
-  virtual void Visit(NameSuperExpression* node) = 0;
+  virtual void Visit(NameSuperExpression* node) {}
-  virtual void Visit(NameExpression* node) = 0;
+  virtual void Visit(NameExpression* node) {}
-  virtual void Visit(TupleName* node) = 0;
+  virtual void Visit(TupleName* node) {}
-  virtual void Visit(VariantName* node) = 0;
+  virtual void Visit(VariantName* node) {}
-  virtual void Visit(AnnotatedName* node) = 0;
+  virtual void Visit(AnnotatedName* node) {}
+
+  void Visit(AnyName& node); // variant
 
   // Type
 
-  virtual void Visit(TypeConstructor* node) = 0;
+  virtual void Visit(TypeConstructor* node) {}
-  virtual void Visit(TupleType* node) = 0;
+  virtual void Visit(TupleType* node) {}
-  virtual void Visit(VariantType* node) = 0;
+  virtual void Visit(VariantType* node) {}
-  virtual void Visit(AnnotatedType* node) = 0;
+  virtual void Visit(AnnotatedType* node) {}
-  virtual void Visit(ParametrizedType* node) = 0;
+  virtual void Visit(ParametrizedType* node) {}
-  virtual void Visit(TypeExpression* node) = 0;
+  virtual void Visit(TypeExpression* node) {}
+
+  void Visit(AnyType& node); // variant
+  void Visit(TypeSubExpression& node); // variant
+
+  void Visit(TypeParameter& node); // variant
 
   // Typeclass
 
-  virtual void Visit(AnnotatedTypeclass* node) = 0;
+  virtual void Visit(AnnotatedTypeclass* node) {}
-  virtual void Visit(ParametrizedTypeclass* node) = 0;
+  virtual void Visit(ParametrizedTypeclass* node) {}
-  virtual void Visit(TypeclassExpression* node) = 0;
+  virtual void Visit(TypeclassExpression* node) {}
 
   // Identifiers, constants, etc. -----------------
 
-  virtual void Visit(FloatNumberLiteral* node) = 0;
+  virtual void Visit(AnyIdentifier* node) {} // std::string
-  virtual void Visit(NumberLiteral* node) = 0;
+
-  virtual void Visit(StringLiteral* node) = 0;
+  virtual void Visit(FloatNumberLiteral* node) {}
-  virtual void Visit(CharLiteral* node) = 0;
+  virtual void Visit(NumberLiteral* node) {}
+  virtual void Visit(StringLiteral* node) {}
+  virtual void Visit(CharLiteral* node) {}
+
+  void Visit(Literal& node); // variant
+
+  void Visit(NameSubSuperExpression& node); // variant
 };
 
 } // namespace interpreter

src/print_visitor.cpp

@@ -24,8 +24,8 @@ void PrintVisitor::Visit(SourceFile* node) {
 
 void PrintVisitor::Visit(Sources* node) {
   out_ << "<Sources>\n\n";
-  for (auto& source_statement : node->statements) {
+  for (auto& statement : node->statements) {
-    Visitor::Visit(source_statement);
+    Visitor::Visit(statement);
   }
   out_ << "\n</Sources>";
 }
@@ -254,22 +254,113 @@ void PrintVisitor::Visit(DefinitionArgument* node) {
 
 // Flow control -----------------
 
-void PrintVisitor::Visit(Match* node) {}
+void PrintVisitor::Visit(Match* node) {
-void PrintVisitor::Visit(Condition* node) {}
+  out_ << "<Match> ";
-void PrintVisitor::Visit(DoWhileLoop* node) {}
+  Visitor::Visit(node->value);
-void PrintVisitor::Visit(WhileLoop* node) {};
+  out_ << " with\n";
-void PrintVisitor::Visit(ForLoop* node) {};
+  for (auto& match_case : node->matches) {
-void PrintVisitor::Visit(LoopLoop* node) {};
+    out_ << "| ";
+    Visitor::Visit(match_case.value);
+    if (match_case.condition.has_value()) {
+      out_ << " ? ";
+      Visitor::Visit(match_case.condition.value());
+    }
+    if (match_case.statement.has_value()) {
+      out_ << " -> ";
+      Visitor::Visit(match_case.statement.value());
+    }
+    out_ << '\n';
+  }
+  out_ << "</Match>\n";
+}
+
+void PrintVisitor::Visit(Condition* node) {
+  out_ << "<If> ";
+  Visitor::Visit(node->conditions[0]);
+  out_ << " then\n";
+  Visitor::Visit(node->statements[0]);
+  out_ << '\n';
+  for (size_t i = 1; i < node->conditions.size(); ++i) {
+      out_ << "elif ";
+      Visitor::Visit(node->conditions[i]);
+      out_ << " then\n";
+      Visitor::Visit(node->statements[i]);
+      out_ << '\n';
+  }
+  if (node->statements.size() > node->conditions.size()) {
+    out_ << "else ";
+    Visitor::Visit(node->statements[node->conditions.size()]);
+    out_ << '\n';
+  }
+  out_ << "</If>\n";
+}
+
+void PrintVisitor::Visit(DoWhileLoop* node) {
+  out_ << "<DoWhile>\n";
+  Visitor::Visit(node->statement);
+  out_ << "\nwhile\n";
+  Visitor::Visit(node->condition);
+  out_ << "\n</DoWhile>\n";
+}
+
+void PrintVisitor::Visit(WhileLoop* node) {
+  out_ << "<While>\n";
+  Visitor::Visit(node->statement);
+  out_ << "\ndo\n";
+  Visitor::Visit(node->condition);
+  out_ << "\n</While>\n";
+}
+void PrintVisitor::Visit(ForLoop* node) {
+  out_ << "<For>\n";
+  Visitor::Visit(node->variable);
+  out_ << "\nin\n";
+  Visitor::Visit(node->interval);
+  out_ << "\ndo\n";
+  Visitor::Visit(node->statement);
+  out_ << "</For>\n";
+}
+
+void PrintVisitor::Visit(LoopLoop* node) {
+  out_ << "<Loop>\n";
+  Visitor::Visit(node->statement);
+  out_ << "<\n/Loop>\n";
+}
 
 // Statements, expressions, blocks, etc. -----------------
 
-void PrintVisitor::Visit(Block* node) {}
+void PrintVisitor::Visit(Block* node) {
-void PrintVisitor::Visit(ScopedStatement* node) {}
+  out_ << "<Block> {\n";
+  for (auto& statement : node->statements) {
+    Visitor::Visit(statement);
+  }
+  out_ << "} </Block>\n";
+}
+
+void PrintVisitor::Visit(ScopedStatement* node) {
+  out_ << "<Scoped> ( ";
+  Visitor::Visit(node->statement);
+  out_ << " ) </Scoped>";
+}
 
 // Operators
 
-void PrintVisitor::Visit(BinaryOperatorExpression* node) {}
+void PrintVisitor::Visit(BinaryOperatorExpression* node) {
-void PrintVisitor::Visit(UnaryOperatorExpression* node) {}
+  out_ << "<BinaryOperator> ";
+  Visitor::Visit(node->left_expression);
+  out_ << ' ';
+  Visit(&node->operator_name);
+  out_ << ' ';
+  Visitor::Visit(node->right_expression);
+  out_ << " </BinaryOperator>";
+}
+
+void PrintVisitor::Visit(UnaryOperatorExpression* node) {
+  out_ << "<UnaryOperator> ";
+  Visit(&node->operator_name);
+  out_ << ' ';
+  Visitor::Visit(node->expression);
+  out_ << " </UnaryOperator>";
+}
 
 // Simple Expressions