4 files changed, 24 insertions, 50 deletions

diff --git a/MoonParser/ast.cpp b/MoonParser/ast.cpp
index dbf5d17..852593b 100644
--- a/MoonParser/ast.cpp
+++ b/MoonParser/ast.cpp
@@ -14,12 +14,10 @@ traversal ast_node::traverse(const std::function<traversal (ast_node*)>& func) {
         return func(this);
 }
 
-ast_node* ast_node::getByPath(std::initializer_list<std::size_t>) {
+ast_node* ast_node::getByPath(std::initializer_list<size_t>) {
         return nullptr;
 }
 
-void ast_node::eachChild(const std::function<void (ast_node*)>&) { }
-
 bool ast_node::visitChild(const std::function<bool (ast_node*)>&) {
         return false;
 }
@@ -70,13 +68,14 @@ traversal ast_container::traverse(const std::function<traversal (ast_node*)>& fu
         return traversal::Continue;
 }
 
-ast_node* ast_container::getByPath(std::initializer_list<std::size_t> paths) {
+ast_node* ast_container::getByPath(std::initializer_list<size_t> paths) {
         ast_node* current = this;
         auto it = paths.begin();
         while (it != paths.end()) {
                 ast_node* findNode = nullptr;
+                size_t id = *it;
                 current->visitChild([&](ast_node* node) {
-                        if (node->getId() == *it) {
+                        if (node->getId() == id) {
                                 findNode = node;
                                 return true;
                         }
@@ -93,23 +92,6 @@ ast_node* ast_container::getByPath(std::initializer_list<std::size_t> paths) {
         return current;
 }
 
-void ast_container::eachChild(const std::function<void (ast_node*)>& func) {
-        const auto& members = this->members();
-        for (auto member : members) {
-                if (_ast_ptr* ptr = ast_cast<_ast_ptr>(member)) {
-                        if (ptr->get()) {
-                                func(ptr->get());
-                        }
-                } else if (_ast_list* list = ast_cast<_ast_list>(member)) {
-                        for (auto obj : list->objects()) {
-                                if (obj) {
-                                        func(obj);
-                                }
-                        }
-                }
-        }
-}
-
 bool ast_container::visitChild(const std::function<bool (ast_node*)>& func) {
         const auto& members = this->members();
         for (auto member : members) {
diff --git a/MoonParser/ast.hpp b/MoonParser/ast.hpp
index 982eea8..d239eac 100644
--- a/MoonParser/ast.hpp
+++ b/MoonParser/ast.hpp
@@ -64,9 +64,7 @@ public:
      */
         virtual traversal traverse(const std::function<traversal (ast_node*)>& func);
 
-        virtual ast_node* getByPath(std::initializer_list<std::size_t> paths);
-
-        virtual void eachChild(const std::function<void (ast_node*)>& func);
+        virtual ast_node* getByPath(std::initializer_list<size_t> paths);
 
         virtual bool visitChild(const std::function<bool (ast_node*)>& func);
 
@@ -135,12 +133,10 @@ public:
      */
     virtual void construct(ast_stack& st) override;
 
-        virtual ast_node* getByPath(std::initializer_list<std::size_t> paths) override;
+        virtual ast_node* getByPath(std::initializer_list<size_t> paths) override;
 
         virtual traversal traverse(const std::function<traversal (ast_node*)>& func) override;
 
-        virtual void eachChild(const std::function<void (ast_node*)>& func) override;
-
         virtual bool visitChild(const std::function<bool (ast_node*)>& func) override;
 
         virtual ast_node* getChild(int index) const override;
diff --git a/MoonParser/moon_ast.cpp b/MoonParser/moon_ast.cpp
index 3c433ae..fcbaa90 100644
--- a/MoonParser/moon_ast.cpp
+++ b/MoonParser/moon_ast.cpp
@@ -156,22 +156,10 @@ public:
                 if (root) {
                         std::cout << "compiled!\n\n";
                         std::vector<std::string> out;
-                        root->eachChild([&](ast_node* node) {
-                                switch (node->getId()) {
-                                        case "Block"_id:
-                                                pushScope();
-                                                transformBody(static_cast<Body_t*>(node), out, true);
-                                                popScope();
-                                                break;
-                                        default: break;
-                                }
-                        });
-                        std::string result;
-                        if (out.size() == 1) {
-                                result = std::move(out.front());
-                        } else if (out.size() > 1) {
-                                result = join(out, "\n"sv);
-                        }
+                        pushScope();
+                        transformBlock(root->block, out);
+                        popScope();
+                        std::string result = std::move(out.back());
                         std::cout << result << '\n';
                 } else {
                         std::cout << "compile failed!\n";
@@ -807,9 +795,9 @@ private:
                 out.push_back(clearBuf());
         }
 
-        void transformBody(Body_t* body, std::vector<std::string>& out, bool implicitReturn = false) {
+        void transformCodes(ast_node* nodes, std::vector<std::string>& out, bool implicitReturn) {
                 if (implicitReturn) {
-                        auto last = lastStatementFrom(body);
+                        auto last = lastStatementFrom(nodes);
                         if (ast_is<ExpList_t>(last->content)) {
                                 auto expList = static_cast<ExpList_t*>(last->content.get());
                                 auto expListLow = new_ptr<ExpListLow_t>();
@@ -821,7 +809,7 @@ private:
                         }
                 }
                 std::vector<std::string> temp;
-                body->traverse([&](ast_node* node) {
+                nodes->traverse([&](ast_node* node) {
                         switch (node->getId()) {
                                 case "Statement"_id:
                                         transformStatement(static_cast<Statement_t*>(node), temp);
@@ -832,6 +820,14 @@ private:
                 out.push_back(join(temp));
         }
 
+        void transformBody(Body_t* body, std::vector<std::string>& out, bool implicitReturn = false) {
+                transformCodes(body, out, implicitReturn);
+        }
+
+        void transformBlock(Block_t* block, std::vector<std::string>& out, bool implicitReturn = true) {
+                transformCodes(block, out, implicitReturn);
+        }
+
         void transformReturn(Return_t* returnNode, std::vector<std::string>& out) {
                 if (auto valueList = returnNode->valueList.get()) {
                         if (auto singleValue = singleValueFrom(valueList)) {
diff --git a/MoonParser/parser.hpp b/MoonParser/parser.hpp
index ae83215..a84b9a3 100644
--- a/MoonParser/parser.hpp
+++ b/MoonParser/parser.hpp
@@ -17,15 +17,15 @@
 #include <locale>
 
 // const str hash helper functions
-inline constexpr std::size_t hash(char const* input)
+inline constexpr size_t hash(char const* input)
 {
         return *input ? *input + 33ull * hash(input + 1) : 5381;
 }
-inline std::size_t hash(const char* input, int size, int index)
+inline size_t hash(const char* input, int size, int index)
 {
         return index < size ? input[index] + 33ull * hash(input, size, index + 1) : 5381;
 }
-inline std::size_t constexpr operator"" _id(const char* s, size_t)
+inline size_t constexpr operator"" _id(const char* s, size_t)
 {
         return hash(s);
 }