started to develop build_visitor

include/build_visitor.hpp

@@ -0,0 +1,148 @@
+#pragma once
+
+// for clangd
+#include "visitor.hpp"
+#include "parse_tree.hpp"
+
+namespace interpreter {
+
+class BuildVisitor : public Visitor {
+public:
+  BuildVisitor(const parser::ParseTree& parse_tree) : parse_tree_(parse_tree) {}
+
+  void VisitSourceFile(SourceFile* source_file) override {
+    current_node_ = parse_tree_.GetRoot();
+    Visit(source_file);
+  }
+
+private:
+  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;
+
+  void Visit(SourceStatement& node) override; // variant
+  void Visit(ImportSymbol& node) override; // variant
+
+  // 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;
+
+  void Visit(FunctionDeclarationType& node) override; // variant
+
+  // 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;
+
+  void Visit(FlowControl& node) override; // variant
+
+  // Statements, expressions, blocks, etc. -----------------
+
+  void Visit(Block* node) override;
+  void Visit(ScopedStatement* node) override;
+
+  void Visit(LoopControlExpression& node) override; // enum
+
+  void Visit(SubExpressionToken& node) override; // variant
+  void Visit(SubExpression& node) override; // variant
+  void Visit(PrefixedExpression& node) override; // variant
+  void Visit(Expression& node) override; // variant
+  void Visit(SuperExpression& node) override; // variant
+
+  void Visit(BlockStatement& node) override; // variant
+
+  // 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;
+
+  void Visit(FunctionArgument& node) override; // variant
+
+  // 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;
+
+  void Visit(AnyName& node) override; // variant
+
+  // 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;
+
+  void Visit(AnyType& node) override; // variant
+  void Visit(TypeSubExpression& node) override; // variant
+
+  void Visit(TypeParameter& node) override; // variant
+
+  // 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;
+
+  void Visit(Literal& node) override; // variant
+
+  void Visit(NameSubSuperExpression& node) override; // variant
+private:
+  const parser::ParseTree& parse_tree_;
+  parser::ParseTree::Node current_node_;
+};
+
+} // namespace interpreter

include/interpreter_tree.hpp

@@ -270,6 +270,7 @@ struct Partition : public Node {
 };
 
 struct Namespace : public Node {
+  bool is_const;
   std::variant<
     std::unique_ptr<DefinedAnnotatedName>,
     std::unique_ptr<DefinedType>> name;

include/node.hpp

@@ -15,9 +15,9 @@ class Visitor;
 
 struct Node {
 //public:
-  Node(info::GlobalInfo& global_info) : global_info_(global_info) {}
+  //Node(info::GlobalInfo& global_info) : global_info_(global_info) {}
 
-  virtual void Accept(Visitor* visitor);
+  // ?? not needed ?? virtual void Accept(Visitor* visitor);
 
   /* ------------ use visitor instead ------------
   virtual void build(parser::ParseTree::Cursor& cursor) = 0; // build tree from parse tree

include/parse_token_types.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <string>
+
+namespace parser {
+
+namespace tokens {
+
+// Sources -----------------
+
+const std::string SourceFile = "source_file";
+const std::string Sources = "sources";
+
+// Namespaces, partittions -----------------
+
+const std::string Partition = "partition";
+
+// Definitions -----------------
+
+const std::string ImportStatement = "import_statement";
+const std::string UsageDefinition = "usage_definition";
+const std::string AliasDefinition = "alias_definition";
+const std::string VariableDefinition = "variable_definition";
+const std::string FunctionDeclaration = "function_declaration";
+const std::string FunctionDefinition = "function_definition";
+const std::string AliasTypeDefinition = "alias_type_definition";
+const std::string TypeDefinition = "type_definition";
+const std::string TypeclassDefinition = "typeclass_definition";
+
+const std::string SourceStatement = "source_statement";
+const std::string ImportSymbol = "import_symbol";
+
+// Definition parts
+
+const std::string DefinedName = "defined_name";
+const std::string DefinedAnnotatedName = "defined_annotated_name";
+const std::string DefinedType = "defined_type";
+const std::string DefinedTypeclass = "defined_typeclass";
+const std::string DefinitionParameter = "definition_parameter";
+const std::string DefinitionArgument = "definition_argument";
+
+const std::string FunctionDeclarationType = "function_declaration_type";
+
+// Flow control -----------------
+
+const std::string Match = "match";
+const std::string Condition = "condition";
+const std::string DoWhileLoop = "do_while_loop";
+const std::string WhileLoop = "while_loop";
+const std::string ForLoop = "for_loop";
+const std::string LoopLoop = "loop_loop";
+
+const std::string FlowControl = "flow_control";
+
+// Statements, expressions, blocks, etc. -----------------
+
+
+
+} // namespace tokens
+
+} // namespace parser

include/parse_tree.hpp

@@ -12,13 +12,13 @@ class ParseTree {
 public:
   class Node {
   public:
-    Node() = delete;
-
     std::string GetType();
     std::pair<size_t, size_t> GetStartPoint();
     std::pair<size_t, size_t> GetEndPoint();
     std::string GetAsSExpression();
 
+    std::string GetValue(); // from source
+
     bool IsNull();
     bool IsNamed();
     bool IsMissing();
@@ -31,14 +31,14 @@ public:
     Node NthNamedChild(size_t n);
     size_t NamedChildCount();
 
-    Node ChildByName(const std::string& name);
+    Node ChildByFieldName(const std::string& name);
 
     // ?? use field id instaed of name ??
     // ?? node equality check needed ??
   private:
     TSNode node_;
   };
-  class Cursor {
+  class Cursor { // ?? needed ??
   public:
     Cursor(const Node& node);
 
@@ -56,9 +56,10 @@ public:
 
   ParseTree(const std::string& input);
 
-  Node GetRoot();
+  Node GetRoot() const;
 private:
   TSTree* tree_;
+  std::string source; // for token value extraction
 };
 
 } // namespace parser

include/print_visitor.hpp

@@ -11,8 +11,7 @@ class PrintVisitor : public Visitor {
 public:
   PrintVisitor(std::ostream& out) : out_(out) {}
 
-  // -----------------
-
+private:
   void Visit(Node* node) override;
 
   // Sources -----------------
@@ -60,6 +59,8 @@ public:
   void Visit(Block* node) override;
   void Visit(ScopedStatement* node) override;
 
+  void Visit(LoopControlExpression& node) override; // enum
+
   // Operators
 
   void Visit(BinaryOperatorExpression* node) override;

include/visitor.hpp

@@ -13,8 +13,7 @@ public:
     Visit(source_file);
   }
 
-  // -----------------
-
+private:
   virtual void Visit(Node* node) {}
 
   // Sources -----------------
@@ -39,8 +38,8 @@ public:
   virtual void Visit(TypeDefinition* node) {}
   virtual void Visit(TypeclassDefinition* node) {}
 
-  void Visit(SourceStatement& node); // variant
-  void Visit(ImportSymbol& node); // variant
+  virtual void Visit(SourceStatement& node); // variant
+  virtual void Visit(ImportSymbol& node); // variant
 
   // Definition parts
 
@@ -51,7 +50,7 @@ public:
   virtual void Visit(DefinitionParameter* node) {}
   virtual void Visit(DefinitionArgument* node) {}
 
-  void Visit(FunctionDeclarationType& node); // variant
+  virtual void Visit(FunctionDeclarationType& node); // variant
 
   // Flow control -----------------
 
@@ -62,7 +61,7 @@ public:
   virtual void Visit(ForLoop* node) {}
   virtual void Visit(LoopLoop* node) {}
 
-  void Visit(FlowControl& node); // variant
+  virtual void Visit(FlowControl& node); // variant
 
   // Statements, expressions, blocks, etc. -----------------
 
@@ -71,13 +70,13 @@ public:
 
   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
+  virtual void Visit(SubExpressionToken& node); // variant
+  virtual void Visit(SubExpression& node); // variant
+  virtual void Visit(PrefixedExpression& node); // variant
+  virtual void Visit(Expression& node); // variant
+  virtual void Visit(SuperExpression& node); // variant
 
-  void Visit(BlockStatement& node); // variant
+  virtual void Visit(BlockStatement& node); // variant
 
   // Operators
 
@@ -91,7 +90,7 @@ public:
   virtual void Visit(VariantExpression* node) {}
   virtual void Visit(ReturnExpression* node) {}
 
-  void Visit(FunctionArgument& node); // variant
+  virtual void Visit(FunctionArgument& node); // variant
 
   // Lambda
 
@@ -105,7 +104,7 @@ public:
   virtual void Visit(VariantName* node) {}
   virtual void Visit(AnnotatedName* node) {}
 
-  void Visit(AnyName& node); // variant
+  virtual void Visit(AnyName& node); // variant
 
   // Type
 
@@ -116,10 +115,10 @@ public:
   virtual void Visit(ParametrizedType* node) {}
   virtual void Visit(TypeExpression* node) {}
 
-  void Visit(AnyType& node); // variant
-  void Visit(TypeSubExpression& node); // variant
+  virtual void Visit(AnyType& node); // variant
+  virtual void Visit(TypeSubExpression& node); // variant
 
-  void Visit(TypeParameter& node); // variant
+  virtual void Visit(TypeParameter& node); // variant
 
   // Typeclass
 
@@ -136,9 +135,9 @@ public:
   virtual void Visit(StringLiteral* node) {}
   virtual void Visit(CharLiteral* node) {}
 
-  void Visit(Literal& node); // variant
+  virtual void Visit(Literal& node); // variant
 
-  void Visit(NameSubSuperExpression& node); // variant
+  virtual void Visit(NameSubSuperExpression& node); // variant
 };
 
 } // namespace interpreter

src/build_visitor.cpp

@@ -0,0 +1,624 @@
+// forclangd
+#include "../include/build_visitor.hpp"
+#include "../include/parse_token_types.hpp"
+
+namespace interpreter {
+
+void BuildVisitor::Visit(Node* node) {
+  // error
+}
+
+// Sources -----------------
+void BuildVisitor::Visit(SourceFile* node) {
+  auto parse_node = current_node_;
+  size_t child_count = parse_node.NamedChildCount();
+
+  node->statements.resize(child_count);
+
+  for (size_t i = 0; i < child_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+      auto current_node_type = current_node_.GetType();
+
+      if (current_node_type == parser::tokens::SourceStatement) {
+        node->statements[i].emplace<SourceStatement>();
+        Visit(std::get<SourceStatement>(node->statements[i]));
+      } else if (current_node_type == parser::tokens::Partition) {
+        node->statements[i].emplace<Partition>();
+        Visit(&std::get<Partition>(node->statements[i]));
+      }
+  }
+  current_node_ = parse_node;
+}
+
+void BuildVisitor::Visit(Sources* node) {
+  auto parse_node = current_node_;
+  size_t child_count = parse_node.NamedChildCount();
+
+  node->statements.resize(child_count);
+
+  for (size_t i = 0; i < child_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i);
+      Visit(node->statements[i]);
+  }
+  current_node_ = parse_node;
+}
+
+// Namespaces, partittions -----------------
+
+void BuildVisitor::Visit(Partition* node) {
+  auto parse_node = current_node_;
+
+  auto name_node = parse_node.ChildByFieldName("name");
+  std::string name = name_node.GetValue();
+
+  if (name == "TEST") {
+      node->type = Partition::Test;
+  } else if (name == "INTERFACE") {
+      node->type = Partition::Interface;
+  } else if (name == "CORE") {
+      node->type = Partition::Core;
+  } else if (name == "LIB") {
+      node->type = Partition::Lib;
+  } else if (name == "MODULE") {
+      node->type = Partition::Module;
+  } else if (name == "EXE") {
+      node->type = Partition::Exe;
+  }
+
+  current_node_ = parse_node.ChildByFieldName("scope");
+
+  node->scope = std::make_unique<Sources>();
+  Visit(node->scope.get());
+}
+
+void BuildVisitor::Visit(Namespace* node) {
+  out_ << "<Namespace> ";
+  if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
+    Visit(std::get<std::unique_ptr<DefinedAnnotatedName>>(node->name).get());
+  } else if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->name)) {
+    Visit(std::get<std::unique_ptr<DefinedType>>(node->name).get());
+  } else {
+    // error
+  }
+  out_ << "{\n";
+  Visit(node->scope.get());
+  out_ << "} </Namespace>\n";
+}
+
+// Definitions -----------------
+
+void BuildVisitor::Visit(ImportStatement* node) {
+  out_ << "<Import> \"" << node->module_name << "\" ";
+  if (node->symbols.size() > 0) {
+    out_ << '\n';
+  }
+  for (auto& symbol : node->symbols) {
+    Visitor::Visit(symbol);
+    out_ << '\n';
+  }
+  out_ << "</Import>\n";
+}
+
+void BuildVisitor::Visit(UsageDefinition* node) {
+  out_ << "<Usage> ";
+  Visit(&node->name);
+  out_ << " = ";
+  Visit(node->import_statement.get());
+  out_ << "</Usage>\n";
+}
+
+void BuildVisitor::Visit(AliasDefinition* node) {
+  out_ << "<Alias> ";
+  Visit(node->type.get());
+  out_ << " = ";
+  Visit(node->value.get());
+  out_ << "</Alias>\n";
+}
+
+void BuildVisitor::Visit(VariableDefinition* node) {
+  out_ << "<Variable> " << (node->is_const ? "const" : "var") << ' ';
+  Visit(&node->name);
+  out_ << " = ";
+  Visitor::Visit(node->value);
+  out_ << "</Variable>\n";
+}
+
+void BuildVisitor::Visit(FunctionDeclaration* node) {
+  out_ << "<FunctionDeclaration> ";
+  Visit(&node->name);
+  out_ << "\n";
+  for (auto& parameter : node->parameters) {
+    Visit(parameter.get());
+  }
+  out_ << " : \n";
+  for (auto& argument_type : node->argument_types) {
+    Visitor::Visit(argument_type);
+  }
+  out_ << "</FunctionDeclaration>\n";
+}
+
+void BuildVisitor::Visit(FunctionDefinition* node) {
+  out_ << "<Function> ";
+  Visit(node->name.get());
+  out_ << " = ";
+  Visitor::Visit(node->value);
+  out_ << "</Function>\n";
+}
+
+void BuildVisitor::Visit(AliasTypeDefinition* node) {
+  out_ << "<AliasType> ";
+  Visit(node->name.get());
+  out_ << " = ";
+  Visit(node->value.get());
+  out_ << "</AliasType>\n";
+}
+
+void BuildVisitor::Visit(TypeDefinition* node) {
+  out_ << "<Type> ";
+  Visit(node->name.get());
+  out_ << " = ";
+  Visitor::Visit(node->value);
+  out_ << "</Type>\n";
+}
+
+void BuildVisitor::Visit(TypeclassDefinition* node) {
+  out_ << "<Typeclass> ";
+  Visit(node->name.get());
+  if (node->requirements.size() > 0) {
+    out_ << " : \n";
+  }
+  for (auto& requirement : node->requirements) {
+    out_ << "& ";
+    Visit(requirement.get());
+  }
+  out_ << "</Typeclass>\n";
+}
+
+// Definition parts
+
+void BuildVisitor::Visit(DefinedName* node) {
+  out_ << "<DefinedName> ";
+  Visit(&node->name);
+  if (node->parameters.size() > 0) {
+    out_ << "\n";
+  }
+  for (auto& parameter : node->parameters) {
+    Visit(parameter.get());
+  }
+  if (node->arguments.size() > 0) {
+    out_ << " : \n";
+  }
+  for (auto& argument : node->arguments) {
+    Visit(argument.get());
+  }
+  out_ << "</DefinedName>\n";
+}
+
+void BuildVisitor::Visit(DefinedAnnotatedName* node) {
+  out_ << "<DefinedAnnotatedName> ";
+  Visit(&node->name);
+  out_ << " : ";
+  if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->type)) {
+    Visit(std::get<std::unique_ptr<DefinedType>>(node->type).get());
+  } else if (std::holds_alternative<std::unique_ptr<DefinedTypeclass>>(node->type)) {
+    Visit(std::get<std::unique_ptr<DefinedTypeclass>>(node->type).get());
+  } else {
+    // no annotation
+  }
+  out_ << " </DefinedAnnotatedName>";
+}
+
+void BuildVisitor::Visit(DefinedType* node) {
+  out_ << "<DefinedType> ";
+  Visit(node->type.get());
+  if (node->parameters.size() > 0) {
+    out_ << "\n";
+  }
+  for (auto& parameter : node->parameters) {
+    Visit(parameter.get());
+  }
+  if (node->arguments.size() > 0) {
+    out_ << " : \n";
+  }
+  for (auto& argument : node->arguments) {
+    Visit(argument.get());
+  }
+  out_ << "</DefinedType>\n";
+}
+
+void BuildVisitor::Visit(DefinedTypeclass* node) {
+  out_ << "<DefinedTypeclass> ";
+  Visit(node->typeclass.get());
+  if (node->parameters.size() > 0) {
+    out_ << "\n";
+  }
+  for (auto& parameter : node->parameters) {
+    Visit(parameter.get());
+  }
+  if (node->arguments.size() > 0) {
+    out_ << " : \n";
+  }
+  for (auto& argument : node->arguments) {
+    Visit(argument.get());
+  }
+  out_ << "</DefinedTypeclass>\n";
+}
+
+void BuildVisitor::Visit(DefinitionParameter* node) {
+  out_ << "<DefinitionParameter> " << (node->typeclasses.size() > 0 ? "(" : "");
+  Visit(&node->type);
+  out_ << ' ';
+  for (auto& typeclass : node->typeclasses) {
+    Visit(typeclass.get());
+  }
+  out_ << "</DefinitionParamater>\n";
+}
+
+void BuildVisitor::Visit(DefinitionArgument* node) {
+  out_ << "<DefinitionArgument> " << (node->types.size() > 0 ? "(" : "");
+  Visit(&node->name);
+  out_ << ' ';
+  for (auto& type : node->types) {
+    Visit(type.get());
+  }
+  out_ << "</DefinitionArgument>\n";
+}
+
+// Flow control -----------------
+
+void BuildVisitor::Visit(Match* node) {
+  out_ << "<Match> ";
+  Visitor::Visit(node->value);
+  out_ << " with\n";
+  for (auto& match_case : node->matches) {
+    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 BuildVisitor::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 BuildVisitor::Visit(DoWhileLoop* node) {
+  out_ << "<DoWhile>\n";
+  Visitor::Visit(node->statement);
+  out_ << "\nwhile\n";
+  Visitor::Visit(node->condition);
+  out_ << "\n</DoWhile>\n";
+}
+
+void BuildVisitor::Visit(WhileLoop* node) {
+  out_ << "<While>\n";
+  Visitor::Visit(node->statement);
+  out_ << "\ndo\n";
+  Visitor::Visit(node->condition);
+  out_ << "\n</While>\n";
+}
+void BuildVisitor::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 BuildVisitor::Visit(LoopLoop* node) {
+  out_ << "<Loop>\n";
+  Visitor::Visit(node->statement);
+  out_ << "<\n/Loop>\n";
+}
+
+// Statements, expressions, blocks, etc. -----------------
+
+void BuildVisitor::Visit(Block* node) {
+  out_ << "<Block> {\n";
+  for (auto& statement : node->statements) {
+    Visitor::Visit(statement);
+  }
+  out_ << "} </Block>\n";
+}
+
+void BuildVisitor::Visit(ScopedStatement* node) {
+  out_ << "<Scoped> ( ";
+  Visitor::Visit(node->statement);
+  out_ << " ) </Scoped>";
+}
+
+// Operators
+
+void BuildVisitor::Visit(BinaryOperatorExpression* node) {
+  out_ << "<BinaryOperator> ";
+  Visitor::Visit(node->left_expression);
+  out_ << ' ';
+  Visit(&node->operator_name);
+  out_ << ' ';
+  Visitor::Visit(node->right_expression);
+  out_ << " </BinaryOperator>";
+}
+
+void BuildVisitor::Visit(UnaryOperatorExpression* node) {
+  out_ << "<UnaryOperator> ";
+  Visit(&node->operator_name);
+  out_ << ' ';
+  Visitor::Visit(node->expression);
+  out_ << " </UnaryOperator>";
+}
+
+// Simple Expressions
+
+void BuildVisitor::Visit(FunctionCallExpression* node) {
+  out_ << "<FunctionCall> ";
+  Visit(node->name.get());
+  out_ << ' ';
+  for (auto& argument : node->arguments) {
+    Visitor::Visit(argument);
+    out_ << ' ';
+  }
+  out_ << "</FunctionCall>";
+}
+
+void BuildVisitor::Visit(TupleExpression* node) {
+  out_ << "<TupleExpression> ";
+  out_ << ' ';
+  for (auto& expression : node->expressions) {
+    out_ << "& ";
+    Visitor::Visit(expression);
+  }
+  out_ << " </TupleExpression>";
+}
+
+void BuildVisitor::Visit(VariantExpression* node) {
+  out_ << "<VariantExpression> ";
+  out_ << ' ';
+  for (auto& expression : node->expressions) {
+    out_ << "& ";
+    Visitor::Visit(expression);
+  }
+  out_ << " </VariantExpression>";
+}
+
+void BuildVisitor::Visit(ReturnExpression* node) {
+  out_ << "<Return> ";
+  Visitor::Visit(node->expression);
+  out_ << " </Return>";
+}
+
+// Lambda
+
+void BuildVisitor::Visit(LambdaFunction* node) {
+  out_ << "<LambdaFunction> \\ ";
+  for (auto& parameter : node->parameters) {
+    Visit(parameter.get());
+  }
+  if (node->parameters.size() > 0) {
+    out_ << " : ";
+  }
+  for (auto& argument : node->arguments) {
+    Visit(argument.get());
+  }
+  out_ << " -> ";
+  Visitor::Visit(node->expression);
+  out_ << " </LambdaFunction>";
+}
+
+// Name
+
+void BuildVisitor::Visit(NameSuperExpression* node) {
+  out_ << "<NameSuperExpression> ";
+  for (auto& variable_namespace : node->namespaces) {
+    Visitor::Visit(variable_namespace);
+    out_ << '.';
+  }
+  for (int i = 0; i < node->expressions.size(); ++i) {
+    Visitor::Visit(node->expressions[i]);
+    if (i + 1 < node->expressions.size()) {
+      out_ << '.';
+    }
+  }
+  out_ << "</NameSupperExpression>\n";
+}
+
+void BuildVisitor::Visit(NameExpression* node) {
+  out_ << "<NameExpression> ";
+  for (auto& variable_namespace : node->namespaces) {
+    Visitor::Visit(variable_namespace);
+    out_ << '.';
+  }
+  for (int i = 0; i < node->names.size(); ++i) {
+    Visit(&node->names[i]);
+    if (i + 1 < node->names.size()) {
+      out_ << '.';
+    }
+  }
+  out_ << "</NameExpression>\n";
+}
+
+void BuildVisitor::Visit(TupleName* node) {
+  out_ << "<TupleName> ";
+  for (auto& name : node->names) {
+    out_ << '&';
+    Visit(name.get());
+  }
+  out_ << "</TupleName>\n";
+}
+
+void BuildVisitor::Visit(VariantName* node) {
+  out_ << "<VariantName> ";
+  for (auto& name : node->names) {
+    out_ << '|';
+    Visit(name.get());
+  }
+  out_ << "</VariantName>\n";
+}
+
+void BuildVisitor::Visit(AnnotatedName* node) {
+  out_ << "<AnnotatedName> ";
+  Visit(&node->name);
+  out_ << ' ';
+  Visit(node->type.get());
+  out_ << " </AnnotatedName>";
+}
+
+// Type
+
+void BuildVisitor::Visit(TypeConstructor* node) {
+  out_ << "<TypeConstructor> ";
+  Visit(node->type.get());
+  out_ << '\n';
+  for (auto& parameter : node->parameters) {
+    Visit(&parameter.first);
+    out_ << " = ";
+    Visitor::Visit(parameter.second);
+    out_ << '\n';
+  }
+  out_ << "</TypeConstructor>\n";
+}
+
+void BuildVisitor::Visit(TupleType* node) {
+  out_ << "<TupleType> ";
+  Visit(&node->type); // optional
+  out_ << ' ';
+  for (auto& entity : node->entities) {
+    out_ << "& ";
+    if (entity.first != "") {
+      Visit(&entity.first);
+      out_ << " : ";
+    }
+    Visitor::Visit(entity.second);
+  }
+  out_ << "</TupleType>";
+}
+
+void BuildVisitor::Visit(VariantType* node) {
+  out_ << "<VariantType> ";
+  Visit(&node->type); // optional
+  out_ << ' ';
+  for (auto& constructor : node->constructors) {
+    out_ << "| ";
+    Visit(&constructor.first);
+    Visit(constructor.second.get());
+  }
+  out_ << "</VariantType>";
+}
+
+void BuildVisitor::Visit(AnnotatedType* node) {
+  out_ << "<AnnotatedType> ";
+  Visit(node->type_expression.get());
+  if (node->annotations.size() > 0) {
+    out_ << " :";
+  }
+  for (auto& annotation : node->annotations) {
+    out_ << " ";
+    Visit(annotation.get());
+  }
+  out_ << "</AnnotatedType>";
+}
+
+void BuildVisitor::Visit(ParametrizedType* node) {
+  out_ << "<ParametrizedType> ";
+  Visit(node->type_expression.get());
+  for (auto& paramater : node->parameters) {
+    out_ << ' ';
+    Visitor::Visit(paramater);
+  }
+  out_ << " </ParamtrizedType>";
+}
+
+void BuildVisitor::Visit(TypeExpression* node) {
+  out_ << "<TypeExpression> ";
+  for (auto& type_namespace : node->namespaces) {
+    Visitor::Visit(type_namespace);
+    out_ << '.';
+  }
+  Visit(&node->type);
+  out_ << " </TypeExpression>";
+}
+
+// Typeclass
+
+void BuildVisitor::Visit(AnnotatedTypeclass* node) {
+  out_ << "<AnnotatedTypeclass> ";
+  Visit(node->typeclass_expression.get());
+  if (node->annotations.size() > 0) {
+    out_ << " :";
+  }
+  for (auto& annotation : node->annotations) {
+    out_ << " ";
+    Visit(annotation.get());
+  }
+  out_ << "</AnnotatedTypeclass>";
+}
+
+void BuildVisitor::Visit(ParametrizedTypeclass* node) {
+  out_ << "<ParametrizedTypeclass> ";
+  Visit(node->typeclass_expression.get());
+  for (auto& paramater : node->parameters) {
+    out_ << ' ';
+    Visitor::Visit(paramater);
+  }
+  out_ << " </ParamtrizedTypeclass>";
+}
+
+void BuildVisitor::Visit(TypeclassExpression* node) {
+  out_ << "<TypeclassExpression> ";
+  for (auto& typeclass_namespace : node->namespaces) {
+    Visitor::Visit(typeclass_namespace);
+    out_ << '.';
+  }
+  Visit(&node->typeclass);
+  out_ << " </TypeclassExpression>";
+}
+
+// Identifiers, constants, etc. -----------------
+
+void BuildVisitor::Visit(AnyIdentifier* node) { // std::string
+  out_ << "<Identifier " << *node << " />";
+}
+
+void BuildVisitor::Visit(FloatNumberLiteral* node) {
+  out_ << "<Identifier " << node->value << " />";
+}
+
+void BuildVisitor::Visit(NumberLiteral* node) {
+  out_ << "<Number " << node->value << " />";
+}
+
+void BuildVisitor::Visit(StringLiteral* node) {
+  out_ << "<String " << node->value << " />";
+}
+
+void BuildVisitor::Visit(CharLiteral* node) {
+  out_ << "<Char " << node->value << " />";
+}
+
+} // namespace interpreter

src/print_visitor.cpp

@@ -62,6 +62,11 @@ void PrintVisitor::Visit(Partition* node) {
 void PrintVisitor::Visit(Namespace* node) {
   out_ << "<Namespace> ";
   if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
+    if (node->is_const) {
+      out_ << "const ";
+    } else {
+      out_ << "var ";
+    }
     Visit(std::get<std::unique_ptr<DefinedAnnotatedName>>(node->name).get());
   } else if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->name)) {
     Visit(std::get<std::unique_ptr<DefinedType>>(node->name).get());
@@ -342,6 +347,17 @@ void PrintVisitor::Visit(ScopedStatement* node) {
   out_ << " ) </Scoped>";
 }
 
+void PrintVisitor::Visit(LoopControlExpression& node) { // enum
+  switch (node) {
+    case LoopControlExpression::Break:
+      out_ << "<Break/>\n";
+      break;
+    case LoopControlExpression::Continue:
+      out_ << "<Continue/>\n";
+      break;
+  }
+}
+
 // Operators
 
 void PrintVisitor::Visit(BinaryOperatorExpression* node) {