From d5546c4dd1809c7b2ce3fdf6cdf427ed20644c5d Mon Sep 17 00:00:00 2001
From: Stephane Del Pino <stephane.delpino44@gmail.com>
Date: Thu, 4 Jul 2019 14:59:38 +0200
Subject: [PATCH] Rename language::Node to language::ASTNode

Done to avoid confusion with mesh nodes
---
 src/language/ASTBuilder.cpp                   | 24 +++---
 src/language/ASTBuilder.hpp                   |  2 +-
 src/language/ASTNode.hpp                      |  2 +-
 .../ASTNodeAffectationExpressionBuilder.cpp   | 12 +--
 .../ASTNodeAffectationExpressionBuilder.hpp   |  2 +-
 ...ASTNodeBinaryOperatorExpressionBuilder.cpp |  8 +-
 ...ASTNodeBinaryOperatorExpressionBuilder.hpp |  2 +-
 src/language/ASTNodeExpressionBuilder.cpp     | 42 +++++-----
 src/language/ASTNodeExpressionBuilder.hpp     |  2 +-
 .../ASTNodeIncDecExpressionBuilder.cpp        |  8 +-
 .../ASTNodeIncDecExpressionBuilder.hpp        |  2 +-
 .../ASTNodeUnaryOperatorExpressionBuilder.cpp |  8 +-
 .../ASTNodeUnaryOperatorExpressionBuilder.hpp |  2 +-
 src/language/ASTPrinter.cpp                   |  4 +-
 src/language/ASTPrinter.hpp                   |  6 +-
 src/language/ASTSymbolTableBuilder.cpp        |  4 +-
 src/language/ASTSymbolTableBuilder.hpp        |  4 +-
 src/language/PugsParser.cpp                   | 82 ++++---------------
 18 files changed, 82 insertions(+), 134 deletions(-)

diff --git a/src/language/ASTBuilder.cpp b/src/language/ASTBuilder.cpp
index 6dbadf263..67485c297 100644
--- a/src/language/ASTBuilder.cpp
+++ b/src/language/ASTBuilder.cpp
@@ -13,7 +13,7 @@ struct ASTBuilder::rearrange : parse_tree::apply<ASTBuilder::rearrange>
 {
   template <typename... States>
   static void
-  transform(std::unique_ptr<Node>& n, States&&... st)
+  transform(std::unique_ptr<ASTNode>& n, States&&... st)
   {
     if (n->children.size() == 1) {
       n = std::move(n->children.back());
@@ -59,7 +59,7 @@ struct ASTBuilder::simplify_unary : parse_tree::apply<ASTBuilder::simplify_unary
 {
   template <typename... States>
   static void
-  transform(std::unique_ptr<Node>& n, States&&... st)
+  transform(std::unique_ptr<ASTNode>& n, States&&... st)
   {
     if (n->children.size() == 1) {
       if (n->is<unary_expression>()) {
@@ -114,7 +114,7 @@ struct ASTBuilder::simplify_statement_bloc : parse_tree::apply<ASTBuilder::simpl
 {
   template <typename... States>
   static void
-  transform(std::unique_ptr<Node>& n, States&&... st)
+  transform(std::unique_ptr<ASTNode>& n, States&&... st)
   {
     if (n->children.size() == 1) {
       if (not n->children[0]->is<language::declaration>()) {
@@ -132,7 +132,7 @@ struct ASTBuilder::simplify_for_statement_bloc : parse_tree::apply<ASTBuilder::s
 {
   template <typename... States>
   static void
-  transform(std::unique_ptr<Node>& n, States&&... st)
+  transform(std::unique_ptr<ASTNode>& n, States&&... st)
   {
     if (n->children.size() == 1) {
       n->remove_content();
@@ -146,7 +146,7 @@ struct ASTBuilder::simplify_for_init : parse_tree::apply<ASTBuilder::simplify_fo
 {
   template <typename... States>
   static void
-  transform(std::unique_ptr<Node>& n, States&&...)
+  transform(std::unique_ptr<ASTNode>& n, States&&...)
   {
     Assert(n->children.size() <= 1);
     if (n->children.size() == 1) {
@@ -160,7 +160,7 @@ struct ASTBuilder::simplify_for_test : parse_tree::apply<ASTBuilder::simplify_fo
 {
   template <typename... States>
   static void
-  transform(std::unique_ptr<Node>& n, States&&...)
+  transform(std::unique_ptr<ASTNode>& n, States&&...)
   {
     Assert(n->children.size() <= 1);
     if (n->children.size() == 1) {
@@ -174,7 +174,7 @@ struct ASTBuilder::simplify_for_post : parse_tree::apply<ASTBuilder::simplify_fo
 {
   template <typename... States>
   static void
-  transform(std::unique_ptr<Node>& n, States&&...)
+  transform(std::unique_ptr<ASTNode>& n, States&&...)
   {
     Assert(n->children.size() <= 1);
     if (n->children.size() == 1) {
@@ -188,7 +188,7 @@ struct ASTBuilder::simplify_stream_statement : parse_tree::apply<ASTBuilder::sim
 {
   template <typename... States>
   static void
-  transform(std::unique_ptr<Node>& n, States&&...)
+  transform(std::unique_ptr<ASTNode>& n, States&&...)
   {
     for (size_t i = 1; i < n->children.size(); ++i) {
       n->children[0]->children.emplace_back(std::move(n->children[i]));
@@ -260,11 +260,11 @@ using selector =
                        ASTBuilder::simplify_stream_statement::on<ostream_statement>>;
 
 template <typename InputT>
-std::unique_ptr<language::Node>
+std::unique_ptr<language::ASTNode>
 ASTBuilder::build(InputT& input)
 {
-  return parse_tree::parse<language::grammar, language::Node, selector, nothing, language::errors>(input);
+  return parse_tree::parse<language::grammar, language::ASTNode, selector, nothing, language::errors>(input);
 }
 
-template std::unique_ptr<language::Node> ASTBuilder::build(read_input<>& input);
-template std::unique_ptr<language::Node> ASTBuilder::build(string_input<>& input);
+template std::unique_ptr<language::ASTNode> ASTBuilder::build(read_input<>& input);
+template std::unique_ptr<language::ASTNode> ASTBuilder::build(string_input<>& input);
diff --git a/src/language/ASTBuilder.hpp b/src/language/ASTBuilder.hpp
index 0fc767cd8..048c77199 100644
--- a/src/language/ASTBuilder.hpp
+++ b/src/language/ASTBuilder.hpp
@@ -18,7 +18,7 @@ struct ASTBuilder
 
  public:
   template <typename InputT>
-  static std::unique_ptr<language::Node> build(InputT& input);
+  static std::unique_ptr<language::ASTNode> build(InputT& input);
 };
 
 #endif   // AST_BUILDER_HPP
diff --git a/src/language/ASTNode.hpp b/src/language/ASTNode.hpp
index f237cdab0..a485cf787 100644
--- a/src/language/ASTNode.hpp
+++ b/src/language/ASTNode.hpp
@@ -65,7 +65,7 @@ class INodeProcessor
   virtual ~INodeProcessor() {}
 };
 
-struct Node : public parse_tree::basic_node<Node>
+struct ASTNode : public parse_tree::basic_node<ASTNode>
 {
   std::shared_ptr<SymbolTable> m_symbol_table;
   std::unique_ptr<INodeProcessor> m_node_processor;
diff --git a/src/language/ASTNodeAffectationExpressionBuilder.cpp b/src/language/ASTNodeAffectationExpressionBuilder.cpp
index 50607980e..498ca65ad 100644
--- a/src/language/ASTNodeAffectationExpressionBuilder.cpp
+++ b/src/language/ASTNodeAffectationExpressionBuilder.cpp
@@ -99,7 +99,7 @@ template <typename OperatorT, typename ValueT, typename DataT>
 class AffectationProcessor final : public INodeProcessor
 {
  private:
-  Node& m_node;
+  ASTNode& m_node;
   DataVariant* p_value{nullptr};
 
   static inline const bool _is_defined{[] {
@@ -116,7 +116,7 @@ class AffectationProcessor final : public INodeProcessor
   }()};
 
  public:
-  AffectationProcessor(Node& node) : m_node{node}
+  AffectationProcessor(ASTNode& node) : m_node{node}
   {
     if constexpr (_is_defined) {
       const std::string& symbol = m_node.children[0]->string();
@@ -151,7 +151,7 @@ template <typename OperatorT, typename DataT>
 class AffectationToStringProcessor final : public INodeProcessor
 {
  private:
-  Node& m_node;
+  ASTNode& m_node;
   DataVariant* p_value{nullptr};
 
   static inline const bool _is_defined{[] {
@@ -164,7 +164,7 @@ class AffectationToStringProcessor final : public INodeProcessor
   }()};
 
  public:
-  AffectationToStringProcessor(Node& node) : m_node{node}
+  AffectationToStringProcessor(ASTNode& node) : m_node{node}
   {
     if constexpr (_is_defined) {
       const std::string& symbol = m_node.children[0]->string();
@@ -199,9 +199,9 @@ class AffectationToStringProcessor final : public INodeProcessor
   }
 };   // namespace language
 
-ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(Node& n)
+ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode& n)
 {
-  auto set_affectation_processor = [](Node& n, const auto& operator_v) {
+  auto set_affectation_processor = [](ASTNode& n, const auto& operator_v) {
     auto set_affectation_processor_for_data = [&](const auto& value, const DataType& data_type) {
       using OperatorT = std::decay_t<decltype(operator_v)>;
       using ValueT    = std::decay_t<decltype(value)>;
diff --git a/src/language/ASTNodeAffectationExpressionBuilder.hpp b/src/language/ASTNodeAffectationExpressionBuilder.hpp
index 2495702ed..424ebed63 100644
--- a/src/language/ASTNodeAffectationExpressionBuilder.hpp
+++ b/src/language/ASTNodeAffectationExpressionBuilder.hpp
@@ -7,7 +7,7 @@ namespace language
 {
 struct ASTNodeAffectationExpressionBuilder
 {
-  ASTNodeAffectationExpressionBuilder(Node& node);
+  ASTNodeAffectationExpressionBuilder(ASTNode& node);
 };
 }   // namespace language
 
diff --git a/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp b/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp
index b9f067147..ab3fe55db 100644
--- a/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp
+++ b/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp
@@ -177,7 +177,7 @@ struct BinOp<language::divide_op>
 template <typename BinaryOpT, typename A_DataT, typename B_DataT>
 class BinaryExpressionProcessor final : public INodeProcessor
 {
-  Node& m_node;
+  ASTNode& m_node;
 
   PUGS_INLINE auto
   eval(const DataVariant& a, const DataVariant& b, DataVariant& value)
@@ -220,7 +220,7 @@ class BinaryExpressionProcessor final : public INodeProcessor
   }()};
 
  public:
-  BinaryExpressionProcessor(Node& node) : m_node{node}
+  BinaryExpressionProcessor(ASTNode& node) : m_node{node}
   {
     if constexpr (not _is_defined) {
       throw parse_error("invalid operands to binary expression", std::vector{m_node.begin()});
@@ -239,9 +239,9 @@ class BinaryExpressionProcessor final : public INodeProcessor
   }
 };
 
-ASTNodeBinaryOperatorExpressionBuilder::ASTNodeBinaryOperatorExpressionBuilder(Node& n)
+ASTNodeBinaryOperatorExpressionBuilder::ASTNodeBinaryOperatorExpressionBuilder(ASTNode& n)
 {
-  auto set_binary_operator_processor = [](Node& n, const auto& operator_v) {
+  auto set_binary_operator_processor = [](ASTNode& n, const auto& operator_v) {
     auto set_binary_operator_processor_for_data_b = [&](const auto data_a, const DataType& data_type_b) {
       using OperatorT = std::decay_t<decltype(operator_v)>;
       using DataTA    = std::decay_t<decltype(data_a)>;
diff --git a/src/language/ASTNodeBinaryOperatorExpressionBuilder.hpp b/src/language/ASTNodeBinaryOperatorExpressionBuilder.hpp
index 96d9efda6..3f38260f1 100644
--- a/src/language/ASTNodeBinaryOperatorExpressionBuilder.hpp
+++ b/src/language/ASTNodeBinaryOperatorExpressionBuilder.hpp
@@ -7,7 +7,7 @@ namespace language
 {
 struct ASTNodeBinaryOperatorExpressionBuilder
 {
-  ASTNodeBinaryOperatorExpressionBuilder(Node& node);
+  ASTNodeBinaryOperatorExpressionBuilder(ASTNode& node);
 };
 }   // namespace language
 
diff --git a/src/language/ASTNodeExpressionBuilder.cpp b/src/language/ASTNodeExpressionBuilder.cpp
index e14440864..d97f15b9f 100644
--- a/src/language/ASTNodeExpressionBuilder.cpp
+++ b/src/language/ASTNodeExpressionBuilder.cpp
@@ -10,12 +10,12 @@
 
 namespace language
 {
-class NodeList final : public INodeProcessor
+class ASTNodeList final : public INodeProcessor
 {
-  Node& m_node;
+  ASTNode& m_node;
 
  public:
-  NodeList(Node& node) : m_node{node} {}
+  ASTNodeList(ASTNode& node) : m_node{node} {}
 
   void
   execute(ExecUntilBreakOrContinue& exec_policy)
@@ -41,10 +41,10 @@ class NoProcess final : public INodeProcessor
 
 class IfStatement final : public INodeProcessor
 {
-  Node& m_node;
+  ASTNode& m_node;
 
  public:
-  IfStatement(Node& node) : m_node{node} {}
+  IfStatement(ASTNode& node) : m_node{node} {}
 
   void
   execute(ExecUntilBreakOrContinue& exec_policy)
@@ -75,10 +75,10 @@ class IfStatement final : public INodeProcessor
 
 class DoWhileStatement final : public INodeProcessor
 {
-  Node& m_node;
+  ASTNode& m_node;
 
  public:
-  DoWhileStatement(Node& node) : m_node{node} {}
+  DoWhileStatement(ASTNode& node) : m_node{node} {}
 
   void
   execute(ExecUntilBreakOrContinue& exec_policy)
@@ -111,10 +111,10 @@ class DoWhileStatement final : public INodeProcessor
 
 class WhileStatement final : public INodeProcessor
 {
-  Node& m_node;
+  ASTNode& m_node;
 
  public:
-  WhileStatement(Node& node) : m_node{node} {}
+  WhileStatement(ASTNode& node) : m_node{node} {}
 
   void
   execute(ExecUntilBreakOrContinue& exec_policy)
@@ -147,10 +147,10 @@ class WhileStatement final : public INodeProcessor
 
 class ForStatement final : public INodeProcessor
 {
-  Node& m_node;
+  ASTNode& m_node;
 
  public:
-  ForStatement(Node& node) : m_node{node} {}
+  ForStatement(ASTNode& node) : m_node{node} {}
 
   void
   execute(ExecUntilBreakOrContinue& exec_policy)
@@ -186,11 +186,11 @@ class ForStatement final : public INodeProcessor
 
 class NameExpression final : public INodeProcessor
 {
-  Node& m_node;
+  ASTNode& m_node;
   DataVariant* p_value{nullptr};
 
  public:
-  NameExpression(Node& node) : m_node{node}
+  NameExpression(ASTNode& node) : m_node{node}
   {
     const std::string& symbol = m_node.string();
     auto [i_symbol, found]    = m_node.m_symbol_table->find(symbol);
@@ -231,11 +231,11 @@ class ContinueExpression final : public INodeProcessor
 
 class OStreamObject final : public INodeProcessor
 {
-  Node& m_node;
+  ASTNode& m_node;
   std::ostream& m_os;
 
  public:
-  OStreamObject(Node& node, std::ostream& os) : m_node{node}, m_os(os)
+  OStreamObject(ASTNode& node, std::ostream& os) : m_node{node}, m_os(os)
   {
     ;
   }
@@ -264,10 +264,10 @@ class OStreamObject final : public INodeProcessor
 namespace internal
 {
 void
-build_node_type(Node& n)
+build_node_type(ASTNode& n)
 {
   if (n.is_root() or n.is<language::bloc>()) {
-    n.m_node_processor = std::make_unique<NodeList>(n);
+    n.m_node_processor = std::make_unique<ASTNodeList>(n);
   } else if (n.is<language::declaration>()) {
     n.m_node_processor = std::make_unique<NoProcess>();
 
@@ -314,7 +314,7 @@ build_node_type(Node& n)
   } else if (n.is<language::if_statement>()) {
     n.m_node_processor = std::make_unique<IfStatement>(n);
   } else if (n.is<language::statement_bloc>()) {
-    n.m_node_processor = std::make_unique<NodeList>(n);
+    n.m_node_processor = std::make_unique<ASTNodeList>(n);
   } else if (n.is<language::do_while_statement>()) {
     n.m_node_processor = std::make_unique<DoWhileStatement>(n);
   } else if (n.is<language::while_statement>()) {
@@ -322,7 +322,7 @@ build_node_type(Node& n)
   } else if (n.is<language::for_statement>()) {
     n.m_node_processor = std::make_unique<ForStatement>(n);
   } else if (n.is<language::for_statement_bloc>()) {
-    n.m_node_processor = std::make_unique<NodeList>(n);
+    n.m_node_processor = std::make_unique<ASTNodeList>(n);
   } else if (n.is<language::for_init>()) {
     n.m_node_processor = std::make_unique<NoProcess>();
   } else if (n.is<language::for_post>()) {
@@ -350,11 +350,11 @@ build_node_type(Node& n)
 }   // namespace internal
 
 void
-build_node_type(Node& n)
+build_node_type(ASTNode& n)
 {
   Assert(n.is_root());
   Assert(n.is<void>());
-  n.m_node_processor = std::make_unique<NodeList>(n);
+  n.m_node_processor = std::make_unique<ASTNodeList>(n);
   for (auto& child : n.children) {
     internal::build_node_type(*child);
   }
diff --git a/src/language/ASTNodeExpressionBuilder.hpp b/src/language/ASTNodeExpressionBuilder.hpp
index 4dc02c93b..861aac073 100644
--- a/src/language/ASTNodeExpressionBuilder.hpp
+++ b/src/language/ASTNodeExpressionBuilder.hpp
@@ -5,7 +5,7 @@
 
 namespace language
 {
-void build_node_type(Node& n);
+void build_node_type(ASTNode& n);
 }
 
 #endif   // AST_NODE_EXPRESSION_BUILDER_HPP
diff --git a/src/language/ASTNodeIncDecExpressionBuilder.cpp b/src/language/ASTNodeIncDecExpressionBuilder.cpp
index 5594ad0fa..6cc21aa29 100644
--- a/src/language/ASTNodeIncDecExpressionBuilder.cpp
+++ b/src/language/ASTNodeIncDecExpressionBuilder.cpp
@@ -54,7 +54,7 @@ struct IncDecOp<language::post_plusplus>
 template <typename IncDecOpT, typename ValueT, typename DataT>
 class IncDecExpressionProcessor final : public INodeProcessor
 {
-  Node& m_node;
+  ASTNode& m_node;
   DataVariant* p_value{nullptr};
 
   static inline const bool _is_defined{[] {
@@ -68,7 +68,7 @@ class IncDecExpressionProcessor final : public INodeProcessor
   }()};
 
  public:
-  IncDecExpressionProcessor(Node& node) : m_node{node}
+  IncDecExpressionProcessor(ASTNode& node) : m_node{node}
   {
     if constexpr (_is_defined) {
       Assert(m_node.children[0]->is<language::name>());
@@ -90,9 +90,9 @@ class IncDecExpressionProcessor final : public INodeProcessor
   }
 };
 
-ASTNodeIncDecExpressionBuilder::ASTNodeIncDecExpressionBuilder(Node& n)
+ASTNodeIncDecExpressionBuilder::ASTNodeIncDecExpressionBuilder(ASTNode& n)
 {
-  auto set_inc_dec_operator_processor = [](Node& n, const auto& operator_v) {
+  auto set_inc_dec_operator_processor = [](ASTNode& n, const auto& operator_v) {
     auto set_inc_dec_operator_processor_for_data = [&](const auto& value, const DataType& data_type) {
       using OperatorT = std::decay_t<decltype(operator_v)>;
       using ValueT    = std::decay_t<decltype(value)>;
diff --git a/src/language/ASTNodeIncDecExpressionBuilder.hpp b/src/language/ASTNodeIncDecExpressionBuilder.hpp
index 26d35680c..6816a087c 100644
--- a/src/language/ASTNodeIncDecExpressionBuilder.hpp
+++ b/src/language/ASTNodeIncDecExpressionBuilder.hpp
@@ -7,7 +7,7 @@ namespace language
 {
 struct ASTNodeIncDecExpressionBuilder
 {
-  ASTNodeIncDecExpressionBuilder(Node& node);
+  ASTNodeIncDecExpressionBuilder(ASTNode& node);
 };
 }   // namespace language
 
diff --git a/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp b/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp
index c4bdb6f0a..491079f57 100644
--- a/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp
+++ b/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp
@@ -32,7 +32,7 @@ struct UnaryOp<language::unary_not>
 template <typename UnaryOpT, typename ValueT, typename DataT>
 class UnaryExpressionProcessor final : public INodeProcessor
 {
-  Node& m_node;
+  ASTNode& m_node;
 
  public:
   PUGS_INLINE ValueT
@@ -42,7 +42,7 @@ class UnaryExpressionProcessor final : public INodeProcessor
   }
 
  public:
-  UnaryExpressionProcessor(Node& node) : m_node{node} {}
+  UnaryExpressionProcessor(ASTNode& node) : m_node{node} {}
 
   void
   execute(ExecUntilBreakOrContinue& exec_policy)
@@ -52,9 +52,9 @@ class UnaryExpressionProcessor final : public INodeProcessor
   }
 };
 
-ASTNodeUnaryOperatorExpressionBuilder::ASTNodeUnaryOperatorExpressionBuilder(Node& n)
+ASTNodeUnaryOperatorExpressionBuilder::ASTNodeUnaryOperatorExpressionBuilder(ASTNode& n)
 {
-  auto set_unary_operator_processor = [](Node& n, const auto& operator_v) {
+  auto set_unary_operator_processor = [](ASTNode& n, const auto& operator_v) {
     auto set_unary_operator_processor_for_data = [&](const auto& value, const DataType& data_type) {
       using OperatorT = std::decay_t<decltype(operator_v)>;
       using ValueT    = std::decay_t<decltype(value)>;
diff --git a/src/language/ASTNodeUnaryOperatorExpressionBuilder.hpp b/src/language/ASTNodeUnaryOperatorExpressionBuilder.hpp
index ea58aa7d8..59ad3022e 100644
--- a/src/language/ASTNodeUnaryOperatorExpressionBuilder.hpp
+++ b/src/language/ASTNodeUnaryOperatorExpressionBuilder.hpp
@@ -7,7 +7,7 @@ namespace language
 {
 struct ASTNodeUnaryOperatorExpressionBuilder
 {
-  ASTNodeUnaryOperatorExpressionBuilder(Node& node);
+  ASTNodeUnaryOperatorExpressionBuilder(ASTNode& node);
 };
 }   // namespace language
 
diff --git a/src/language/ASTPrinter.cpp b/src/language/ASTPrinter.cpp
index bfb526cc7..0664cb358 100644
--- a/src/language/ASTPrinter.cpp
+++ b/src/language/ASTPrinter.cpp
@@ -6,7 +6,7 @@
 namespace language
 {
 void
-ASTPrinter::_print(std::ostream& os, const Node& node) const
+ASTPrinter::_print(std::ostream& os, const ASTNode& node) const
 {
   os << '(' << rang::fgB::yellow;
   if (node.is_root()) {
@@ -85,7 +85,7 @@ operator<<(std::ostream& os, const ASTPrinter& ast_printer)
   return os;
 }
 
-ASTPrinter::ASTPrinter(const language::Node& node, Format format, std::initializer_list<Info> initializer_list)
+ASTPrinter::ASTPrinter(const language::ASTNode& node, Format format, std::initializer_list<Info> initializer_list)
   : m_node{node}
 {
   if (format == Format::pretty) {
diff --git a/src/language/ASTPrinter.hpp b/src/language/ASTPrinter.hpp
index ec6c8b93b..4d731c840 100644
--- a/src/language/ASTPrinter.hpp
+++ b/src/language/ASTPrinter.hpp
@@ -25,7 +25,7 @@ class ASTPrinter
   };
 
  private:
-  const Node& m_node;
+  const ASTNode& m_node;
 
   InfoBaseType m_info;
 
@@ -38,7 +38,7 @@ class ASTPrinter
   std::string pipe_space;
   std::string space_space;
 
-  void _print(std::ostream& os, const Node& node) const;
+  void _print(std::ostream& os, const ASTNode& node) const;
 
   template <typename NodeVector>
   void _print(std::ostream& os, const NodeVector& node_list) const;
@@ -46,7 +46,7 @@ class ASTPrinter
  public:
   friend std::ostream& operator<<(std::ostream& os, const ASTPrinter& ast_printer);
 
-  ASTPrinter(const Node& node,
+  ASTPrinter(const ASTNode& node,
              Format format                                = Format::pretty,
              std::initializer_list<Info> initializer_list = {Info::all});
 
diff --git a/src/language/ASTSymbolTableBuilder.cpp b/src/language/ASTSymbolTableBuilder.cpp
index ab817f3b5..a0f525522 100644
--- a/src/language/ASTSymbolTableBuilder.cpp
+++ b/src/language/ASTSymbolTableBuilder.cpp
@@ -6,7 +6,7 @@
 namespace language
 {
 void
-ASTSymbolTableBuilder::buildSymbolTable(Node& n, std::shared_ptr<SymbolTable>& symbol_table)
+ASTSymbolTableBuilder::buildSymbolTable(ASTNode& n, std::shared_ptr<SymbolTable>& symbol_table)
 {
   if (n.is<language::bloc>() or (n.is<language::for_statement>())) {
     if (!n.children.empty()) {
@@ -43,7 +43,7 @@ ASTSymbolTableBuilder::buildSymbolTable(Node& n, std::shared_ptr<SymbolTable>& s
   }
 }
 
-ASTSymbolTableBuilder::ASTSymbolTableBuilder(Node& node)
+ASTSymbolTableBuilder::ASTSymbolTableBuilder(ASTNode& node)
 {
   Assert(node.is_root());
   std::shared_ptr symbol_table = std::make_shared<SymbolTable>();
diff --git a/src/language/ASTSymbolTableBuilder.hpp b/src/language/ASTSymbolTableBuilder.hpp
index 4a8cf9c91..86dc7ada7 100644
--- a/src/language/ASTSymbolTableBuilder.hpp
+++ b/src/language/ASTSymbolTableBuilder.hpp
@@ -10,10 +10,10 @@ class SymbolTable;
 class ASTSymbolTableBuilder
 {
  private:
-  void buildSymbolTable(Node& node, std::shared_ptr<SymbolTable>& symbol_table);
+  void buildSymbolTable(ASTNode& node, std::shared_ptr<SymbolTable>& symbol_table);
 
  public:
-  ASTSymbolTableBuilder(Node& root_node);
+  ASTSymbolTableBuilder(ASTNode& root_node);
 
   ASTSymbolTableBuilder(const ASTSymbolTableBuilder&) = delete;
 
diff --git a/src/language/PugsParser.cpp b/src/language/PugsParser.cpp
index dd465fd7f..adff2aa4a 100644
--- a/src/language/PugsParser.cpp
+++ b/src/language/PugsParser.cpp
@@ -32,7 +32,7 @@ namespace language
 namespace internal
 {
 void
-print_dot(std::ostream& os, const Node& n)
+print_dot(std::ostream& os, const ASTNode& n)
 {
   if (n.is_root()) {
     os << "  x" << &n << " [ label=\"root \\n" << dataTypeName(n.m_data_type) << "\" ]\n";
@@ -59,7 +59,7 @@ print_dot(std::ostream& os, const Node& n)
 }   // namespace internal
 
 void
-print_dot(std::ostream& os, const Node& n)
+print_dot(std::ostream& os, const ASTNode& n)
 {
   Assert(n.is_root());
   os << "digraph parse_tree\n{\n";
@@ -67,61 +67,10 @@ print_dot(std::ostream& os, const Node& n)
   os << "}\n";
 }
 
-// namespace internal
-// {
-// void
-// build_symbol_table_and_check_declarations(Node& n, std::shared_ptr<SymbolTable>& symbol_table)
-// {
-//   if (n.is<language::bloc>() or (n.is<language::for_statement>())) {
-//     if (!n.children.empty()) {
-//       std::shared_ptr bloc_symbol_table = std::make_shared<SymbolTable>(symbol_table);
-//       n.m_symbol_table                  = bloc_symbol_table;
-//       for (auto& child : n.children) {
-//         build_symbol_table_and_check_declarations(*child, bloc_symbol_table);
-//       }
-//     }
-//   } else {
-//     n.m_symbol_table = symbol_table;
-//     if (n.has_content()) {
-//       if (n.is<language::declaration>()) {
-//         const std::string& symbol = n.children[1]->string();
-//         auto [i_symbol, success]  = symbol_table->add(symbol);
-//         if (not success) {
-//           std::ostringstream error_message;
-//           error_message << "symbol '" << rang::fg::red << symbol << rang::fg::reset << '\'' << " was already
-//           defined!"; throw parse_error(error_message.str(), std::vector{n.begin()});
-//         }
-//       } else if (n.is<language::name>()) {
-//         auto [i_symbol, found] = symbol_table->find(n.string());
-//         if (not found) {
-//           std::ostringstream error_message;
-//           error_message << "undefined symbol '" << rang::fg::red << n.string() << rang::fg::reset << '\'';
-//           throw parse_error(error_message.str(), std::vector{n.begin()});
-//         }
-//       }
-//     }
-
-//     for (auto& child : n.children) {
-//       build_symbol_table_and_check_declarations(*child, symbol_table);
-//     }
-//   }
-// }
-// }   // namespace internal
-
-// void
-// build_symbol_table_and_check_declarations(Node& n)
-// {
-//   Assert(n.is_root());
-//   std::shared_ptr symbol_table = std::make_shared<SymbolTable>();
-//   n.m_symbol_table             = symbol_table;
-//   internal::build_symbol_table_and_check_declarations(n, symbol_table);
-//   std::cout << " - checked symbols declaration\n";
-// }
-
 namespace internal
 {
 void
-check_symbol_initialization(const Node& n, std::shared_ptr<SymbolTable>& symbol_table)
+check_symbol_initialization(const ASTNode& n, std::shared_ptr<SymbolTable>& symbol_table)
 {
   if (n.is<language::bloc>() or n.is<language::for_statement>()) {
     if (!n.children.empty()) {
@@ -167,7 +116,7 @@ check_symbol_initialization(const Node& n, std::shared_ptr<SymbolTable>& symbol_
 }   // namespace internal
 
 void
-check_symbol_initialization(const Node& n)
+check_symbol_initialization(const ASTNode& n)
 {
   std::cerr << rang::fgB::yellow << "warning:" << rang::fg::reset
             << " symbol initialization checking not finished"
@@ -181,7 +130,7 @@ check_symbol_initialization(const Node& n)
 namespace internal
 {
 void
-build_node_data_types(Node& n)
+build_node_data_types(ASTNode& n)
 {
   if (n.is<language::bloc>() or n.is<for_statement>()) {
     if (!n.children.empty()) {
@@ -302,7 +251,7 @@ build_node_data_types(Node& n)
 }   // namespace internal
 
 void
-build_node_data_types(Node& n)
+build_node_data_types(ASTNode& n)
 {
   Assert(n.is_root());
   n.m_data_type = DataType::void_t;
@@ -314,7 +263,7 @@ build_node_data_types(Node& n)
 namespace internal
 {
 void
-check_node_data_types(const Node& n)
+check_node_data_types(const ASTNode& n)
 {
   if (n.m_data_type == DataType::undefined_t) {
     throw parse_error("unexpected error: undefined datatype for AST node for " + n.name(), n.begin());
@@ -327,7 +276,7 @@ check_node_data_types(const Node& n)
 }   // namespace internal
 
 void
-check_node_data_types(const Node& n)
+check_node_data_types(const ASTNode& n)
 {
   Assert(n.is_root());
   internal::check_node_data_types(n);
@@ -337,7 +286,7 @@ check_node_data_types(const Node& n)
 namespace internal
 {
 void
-build_node_values(Node& n, std::shared_ptr<SymbolTable>& symbol_table)
+build_node_values(ASTNode& n, std::shared_ptr<SymbolTable>& symbol_table)
 {
   if (n.is<language::bloc>()) {
     if (!n.children.empty()) {
@@ -380,7 +329,7 @@ build_node_values(Node& n, std::shared_ptr<SymbolTable>& symbol_table)
 }   // namespace internal
 
 void
-build_node_values(Node& n)
+build_node_values(ASTNode& n)
 {
   Assert(n.is_root());
   n.m_data_type                = DataType::void_t;
@@ -392,7 +341,7 @@ build_node_values(Node& n)
 namespace internal
 {
 void
-check_break_or_continue_placement(const Node& n, bool is_inside_loop)
+check_break_or_continue_placement(const ASTNode& n, bool is_inside_loop)
 {
   if (n.is<language::for_statement>() or n.is<language::do_while_statement>() or n.is<language::while_statement>()) {
     for (auto& child : n.children) {
@@ -414,7 +363,7 @@ check_break_or_continue_placement(const Node& n, bool is_inside_loop)
 }   // namespace internal
 
 void
-check_break_or_continue_placement(const Node& n)
+check_break_or_continue_placement(const ASTNode& n)
 {
   Assert(n.is_root());
   internal::check_break_or_continue_placement(n, false);
@@ -423,7 +372,7 @@ check_break_or_continue_placement(const Node& n)
 namespace internal
 {
 void
-simplify_declarations(Node& n)
+simplify_declarations(ASTNode& n)
 {
   if (n.is<language::declaration>()) {
     if (n.children.size() == 3) {
@@ -441,7 +390,7 @@ simplify_declarations(Node& n)
 }   // namespace internal
 
 void
-simplify_declarations(Node& n)
+simplify_declarations(ASTNode& n)
 {
   Assert(n.is_root());
   internal::simplify_declarations(n);
@@ -459,7 +408,7 @@ parser(const std::string& filename)
   std::cout << rang::style::bold << "Parsing file " << rang::style::reset << rang::style::underline << filename
             << rang::style::reset << " ...\n";
 
-  std::unique_ptr<language::Node> root_node;
+  std::unique_ptr<language::ASTNode> root_node;
   read_input input(filename);
   try {
     root_node = ASTBuilder::build(input);
@@ -467,7 +416,6 @@ parser(const std::string& filename)
 
     language::ASTSymbolTableBuilder{*root_node};
 
-    // language::build_symbol_table_and_check_declarations(*root_node);
     language::check_symbol_initialization(*root_node);
     {
       std::string dot_filename{"parse_tree.dot"};
-- 
GitLab