statement node added

include/expression_nodes.hpp

@@ -536,7 +536,6 @@ public:
 
 private:
   std::variant<
-
       // --- flow control
       Match, Condition, Loop,
 
@@ -563,9 +562,7 @@ private:
       Literal,
 
       // --- empty lines
-      EmptyLines
+      EmptyLines>
-
-      >
       expression_;
 
   bool is_scoped_ = false;

include/statement_builders.hpp

@@ -3,17 +3,18 @@
 #include "statement_nodes.hpp"
 #include "tree_sitter_wrapper.hpp"
 
+#include <vector>
+
 namespace builders {
 
-// IN PROGRESS: return type, etc.
+std::vector<nodes::Statement>
-void build_source_file(parser::ParseTree::Node parser_node,
+build_source_file(parser::ParseTree::Node parser_node,
-                       nodes::ExpressionStorage &expression_storage,
+                  nodes::ExpressionStorage &expression_storage,
-                       nodes::TypeStorage &type_storage);
+                  nodes::TypeStorage &type_storage);
 
-// IN PROGRESS: return type, etc.
+nodes::Statement build_statement(parser::ParseTree::Node parser_node,
-void build_statement(parser::ParseTree::Node parser_node,
+                                 nodes::ExpressionStorage &expression_storage,
-                     nodes::ExpressionStorage &expression_storage,
+                                 nodes::TypeStorage &type_storage);
-                     nodes::TypeStorage &type_storage);
 
 nodes::Import build_import(parser::ParseTree::Node parser_node);
 

include/statement_nodes.hpp

@@ -385,4 +385,33 @@ private:
   std::vector<FunctionDefinition> methods_;
 };
 
+class Statement {
+public:
+  template <typename T>
+  Statement(T &&statement) : expression_(std::forward<T>(statement)) {}
+
+  template <typename T> std::optional<T *> get() {
+    if (std::holds_alternative<T>(expression_)) {
+      return &std::get<T>(expression_);
+    }
+    return std::nullopt;
+  }
+
+  template <typename T> std::optional<const T *> get() const {
+    if (std::holds_alternative<T>(expression_)) {
+      return &std::get<T>(expression_);
+    }
+    return std::nullopt;
+  }
+
+  auto get_any() { return &expression_; }
+
+  auto get_any() const { return &expression_; }
+
+private:
+  std::variant<Import, TypeDefinition, FunctionDefinition, TypeclassDefinition,
+               EmptyLines>
+      expression_;
+};
+
 } // namespace nodes

include/statement_printers.hpp

@@ -3,11 +3,14 @@
 #include "basic_printers.hpp"
 #include "statement_nodes.hpp"
 
+#include <vector>
+
 namespace printers {
 
-// void print_source_file(Printer &printer); // TODO
+void print_source_file(const std::vector<nodes::Statement> &statements,
+                       Printer &printer);
 
-// void print_statement(Printer &printer); // TODO
+void print_statement(const nodes::Statement &statements, Printer &printer);
 
 void print_import(const nodes::Import &statement, Printer &printer);
 

src/main.cpp

@@ -2,9 +2,11 @@
 #include <iostream>
 #include <sstream>
 
+#include "basic_printers.hpp"
 #include "error_handling.hpp"
 #include "expression_nodes.hpp"
 #include "statement_builders.hpp"
+#include "statement_printers.hpp"
 #include "type_nodes.hpp"
 
 int main(int argc, char **argv) {
@@ -37,6 +39,9 @@ int main(int argc, char **argv) {
   nodes::ExpressionStorage expression_storage;
   nodes::TypeStorage type_storage;
 
-  builders::build_source_file(parse_tree.get_root(), expression_storage,
+  auto statements = builders::build_source_file(
-                              type_storage);
+      parse_tree.get_root(), expression_storage, type_storage);
+
+  printers::Printer printer(std::cout, 2, 80, false);
+  printers::print_source_file(statements, printer);
 }

src/statement_builders.cpp

@@ -2,86 +2,65 @@
 
 #include "basic_builders.hpp"
 #include "basic_nodes.hpp"
-#include "basic_printers.hpp"
 #include "doc_builders.hpp"
 #include "doc_nodes.hpp"
 #include "error_handling.hpp"
 #include "expression_builders.hpp"
 #include "statement_nodes.hpp"
-#include "statement_printers.hpp"
 #include "tokens.hpp"
 #include "tree_sitter_wrapper.hpp"
 #include "type_builders.hpp"
 #include "type_nodes.hpp"
+
 #include <optional>
 #include <type_traits>
 #include <vector>
 
 namespace builders {
 
-// TODO: return some info ??
 // statement+
-void build_source_file(parser::ParseTree::Node parser_node,
+std::vector<nodes::Statement>
-                       nodes::ExpressionStorage &expression_storage,
+build_source_file(parser::ParseTree::Node parser_node,
-                       nodes::TypeStorage &type_storage) {
+                  nodes::ExpressionStorage &expression_storage,
+                  nodes::TypeStorage &type_storage) {
+  std::vector<nodes::Statement> statements;
+
   auto current_node = parser_node.nth_named_child(0);
   while (!current_node.is_null()) {
-    build_statement(current_node, expression_storage, type_storage);
+    statements.push_back(
-    // TODO: do something with statement
+        build_statement(current_node, expression_storage, type_storage));
     current_node = current_node.next_named_sibling();
   }
+
+  return statements;
 }
 
-// TODO: return some info ??
 // import | type_definition | function_definition | typeclass_definition
-void build_statement(parser::ParseTree::Node parser_node,
+nodes::Statement build_statement(parser::ParseTree::Node parser_node,
-                     nodes::ExpressionStorage &expression_storage,
+                                 nodes::ExpressionStorage &expression_storage,
-                     nodes::TypeStorage &type_storage) {
+                                 nodes::TypeStorage &type_storage) {
   tokens::Type type = tokens::string_to_type(parser_node.get_type());
 
-  printers::Printer printer(std::cout, 2, 80, false);
-
   switch (type) {
   case tokens::Type::IMPORT:
-    build_import(parser_node);
+    return nodes::Statement(build_import(parser_node));
-    printers::print_import(build_import(parser_node),
-                           printer); // TODO TEMPORARY
-    printer.new_indent_line();
-    return;
   case tokens::Type::TYPE_DEFINITION:
-    build_type_definition(parser_node, expression_storage, type_storage);
+    return nodes::Statement(
-    printers::print_type_definition(
+        build_type_definition(parser_node, expression_storage, type_storage));
-        build_type_definition(parser_node, expression_storage, type_storage),
-        printer); // TODO TEMPORARY
-    printer.new_indent_line();
-    return;
   case tokens::Type::FUNCTION_DEFINITION:
-    build_function_definition(parser_node, expression_storage, type_storage);
+    return nodes::Statement(build_function_definition(
-    printers::print_function_definition(
+        parser_node, expression_storage, type_storage));
-        build_function_definition(parser_node, expression_storage,
-                                  type_storage),
-        printer); // TODO TEMPORARY
-    printer.new_indent_line();
-    return;
   case tokens::Type::TYPECLASS_DEFINITION:
-    build_typeclass_definition(parser_node, expression_storage, type_storage);
+    return nodes::Statement(build_typeclass_definition(
-    printers::print_typeclass_definition(
+        parser_node, expression_storage, type_storage));
-        build_typeclass_definition(parser_node, expression_storage,
-                                   type_storage),
-        printer); // TODO TEMPORARY
-    printer.new_indent_line();
-    return;
   case tokens::Type::EMPTY_LINES:
-    build_empty_lines(parser_node);
+    return nodes::Statement(build_empty_lines(parser_node));
-    printers::print_empty_lines(build_empty_lines(parser_node),
-                                printer); // TODO TEMPORARY
-    return;
   default:
     error_handling::handle_parsing_error("Unexprected statement node type",
                                          parser_node);
   }
   error_handling::handle_general_error("Unreachable");
-  exit(1); // unreachable} // IN PROCESS
+  exit(1); // unreachable
 }
 
 // ('::' | 'import') simple_name ('=' simple_name)? (':' identifier*)?

src/statement_printers.cpp

@@ -8,6 +8,40 @@
 
 namespace printers {
 
+void print_source_file(const std::vector<nodes::Statement> &statements,
+                       Printer &printer) {
+  for (auto &statement : statements) {
+    print_statement(statement, printer);
+  }
+}
+
+void print_statement(const nodes::Statement &statement, Printer &printer) {
+  switch (statement.get_any()->index()) {
+  case 0: // Import
+    print_import(*statement.get<nodes::Import>().value(), printer);
+    printer.new_indent_line();
+    break;
+  case 1: // TypeDefinition
+    print_type_definition(*statement.get<nodes::TypeDefinition>().value(),
+                          printer);
+    printer.new_indent_line();
+    break;
+  case 2: // FunctionDefinition
+    print_function_definition(
+        *statement.get<nodes::FunctionDefinition>().value(), printer);
+    printer.new_indent_line();
+    break;
+  case 3: // TypeclassDefinition
+    print_typeclass_definition(
+        *statement.get<nodes::TypeclassDefinition>().value(), printer);
+    printer.new_indent_line();
+    break;
+  case 4: // EmptyLines
+    print_empty_lines(*statement.get<nodes::EmptyLines>().value(), printer);
+    break;
+  }
+}
+
 void print_import(const nodes::Import &statement, Printer &printer) {
   printer.print(":: ");