diff --git a/src/language/ASTNodeExpressionBuilder.cpp b/src/language/ASTNodeExpressionBuilder.cpp
index 756d40245c5d1dae18370a7debc1178ab62bd5d9..8eb9b8995692a76654d7a1ab36131409cae354b0 100644
--- a/src/language/ASTNodeExpressionBuilder.cpp
+++ b/src/language/ASTNodeExpressionBuilder.cpp
@@ -10,7 +10,7 @@
 
 #include <Demangle.hpp>
 
-class ASTNodeList final : public INodeProcessor
+class ASTNodeListProcessor final : public INodeProcessor
 {
   ASTNode& m_node;
 
@@ -29,10 +29,10 @@ class ASTNodeList final : public INodeProcessor
     }
   }
 
-  ASTNodeList(ASTNode& node) : m_node{node} {}
+  ASTNodeListProcessor(ASTNode& node) : m_node{node} {}
 };
 
-class NoProcess final : public INodeProcessor
+class FakeProcessor final : public INodeProcessor
 {
  public:
   std::string
@@ -48,10 +48,10 @@ class NoProcess final : public INodeProcessor
     ;
   }
 
-  NoProcess() = default;
+  FakeProcessor() = default;
 };
 
-class IfStatement final : public INodeProcessor
+class IfProcessor final : public INodeProcessor
 {
   ASTNode& m_node;
 
@@ -88,10 +88,10 @@ class IfStatement final : public INodeProcessor
     }
   }
 
-  IfStatement(ASTNode& node) : m_node{node} {}
+  IfProcessor(ASTNode& node) : m_node{node} {}
 };
 
-class DoWhileStatement final : public INodeProcessor
+class DoWhileProcessor final : public INodeProcessor
 {
   ASTNode& m_node;
 
@@ -130,10 +130,10 @@ class DoWhileStatement final : public INodeProcessor
     } while (continuation_test);
   }
 
-  DoWhileStatement(ASTNode& node) : m_node{node} {}
+  DoWhileProcessor(ASTNode& node) : m_node{node} {}
 };
 
-class WhileStatement final : public INodeProcessor
+class WhileProcessor final : public INodeProcessor
 {
   ASTNode& m_node;
 
@@ -172,10 +172,10 @@ class WhileStatement final : public INodeProcessor
     }
   }
 
-  WhileStatement(ASTNode& node) : m_node{node} {}
+  WhileProcessor(ASTNode& node) : m_node{node} {}
 };
 
-class ForStatement final : public INodeProcessor
+class ForProcessor final : public INodeProcessor
 {
   ASTNode& m_node;
 
@@ -217,10 +217,10 @@ class ForStatement final : public INodeProcessor
     }
   }
 
-  ForStatement(ASTNode& node) : m_node{node} {}
+  ForProcessor(ASTNode& node) : m_node{node} {}
 };
 
-class NameExpression final : public INodeProcessor
+class NameProcessor final : public INodeProcessor
 {
   ASTNode& m_node;
   ASTNodeDataVariant* p_value{nullptr};
@@ -238,7 +238,7 @@ class NameExpression final : public INodeProcessor
     m_node.m_value = *p_value;
   }
 
-  NameExpression(ASTNode& node) : m_node{node}
+  NameProcessor(ASTNode& node) : m_node{node}
   {
     const std::string& symbol = m_node.string();
     auto [i_symbol, found]    = m_node.m_symbol_table->find(symbol, m_node.begin());
@@ -247,7 +247,7 @@ class NameExpression final : public INodeProcessor
   }
 };
 
-class BreakExpression final : public INodeProcessor
+class BreakProcessor final : public INodeProcessor
 {
  public:
   std::string
@@ -262,10 +262,10 @@ class BreakExpression final : public INodeProcessor
     exec_policy = ExecUntilBreakOrContinue(ExecUntilBreakOrContinue::JumpType::break_jump);
   }
 
-  BreakExpression() = default;
+  BreakProcessor() = default;
 };
 
-class ContinueExpression final : public INodeProcessor
+class ContinueProcessor final : public INodeProcessor
 {
  public:
   std::string
@@ -280,10 +280,10 @@ class ContinueExpression final : public INodeProcessor
     exec_policy = ExecUntilBreakOrContinue(ExecUntilBreakOrContinue::JumpType::continue_jump);
   }
 
-  ContinueExpression() = default;
+  ContinueProcessor() = default;
 };
 
-class OStreamObject final : public INodeProcessor
+class OStreamProcessor final : public INodeProcessor
 {
   ASTNode& m_node;
   std::ostream& m_os;
@@ -315,7 +315,7 @@ class OStreamObject final : public INodeProcessor
     }
   }
 
-  OStreamObject(ASTNode& node, std::ostream& os) : m_node{node}, m_os(os)
+  OStreamProcessor(ASTNode& node, std::ostream& os) : m_node{node}, m_os(os)
   {
     ;
   }
@@ -325,24 +325,24 @@ void
 ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
 {
   if (n.is<language::bloc>()) {
-    n.m_node_processor = std::make_unique<ASTNodeList>(n);
+    n.m_node_processor = std::make_unique<ASTNodeListProcessor>(n);
   } else if ((n.is<language::eq_op>() or n.is<language::multiplyeq_op>() or n.is<language::divideeq_op>() or
               n.is<language::pluseq_op>() or n.is<language::minuseq_op>())) {
     ASTNodeAffectationExpressionBuilder{n};
 
   } else if (n.is<language::real>()) {
-    n.m_node_processor = std::make_unique<NoProcess>();
+    n.m_node_processor = std::make_unique<FakeProcessor>();
   } else if (n.is<language::integer>()) {
-    n.m_node_processor = std::make_unique<NoProcess>();
+    n.m_node_processor = std::make_unique<FakeProcessor>();
   } else if (n.is<language::literal>()) {
-    n.m_node_processor = std::make_unique<NoProcess>();
+    n.m_node_processor = std::make_unique<FakeProcessor>();
   } else if (n.is<language::true_kw>()) {
-    n.m_node_processor = std::make_unique<NoProcess>();
+    n.m_node_processor = std::make_unique<FakeProcessor>();
   } else if (n.is<language::false_kw>()) {
-    n.m_node_processor = std::make_unique<NoProcess>();
+    n.m_node_processor = std::make_unique<FakeProcessor>();
 
   } else if (n.is<language::name>()) {
-    n.m_node_processor = std::make_unique<NameExpression>(n);
+    n.m_node_processor = std::make_unique<NameProcessor>(n);
 
   } else if (n.is<language::unary_minus>() or n.is<language::unary_not>()) {
     ASTNodeUnaryOperatorExpressionBuilder{n};
@@ -359,33 +359,33 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
     ASTNodeBinaryOperatorExpressionBuilder{n};
 
   } else if (n.is<language::cout_kw>()) {
-    n.m_node_processor = std::make_unique<OStreamObject>(n, std::cout);
+    n.m_node_processor = std::make_unique<OStreamProcessor>(n, std::cout);
   } else if (n.is<language::cerr_kw>()) {
-    n.m_node_processor = std::make_unique<OStreamObject>(n, std::cerr);
+    n.m_node_processor = std::make_unique<OStreamProcessor>(n, std::cerr);
   } else if (n.is<language::clog_kw>()) {
-    n.m_node_processor = std::make_unique<OStreamObject>(n, std::clog);
+    n.m_node_processor = std::make_unique<OStreamProcessor>(n, std::clog);
   } else if (n.is<language::if_statement>()) {
-    n.m_node_processor = std::make_unique<IfStatement>(n);
+    n.m_node_processor = std::make_unique<IfProcessor>(n);
   } else if (n.is<language::statement_bloc>()) {
-    n.m_node_processor = std::make_unique<ASTNodeList>(n);
+    n.m_node_processor = std::make_unique<ASTNodeListProcessor>(n);
   } else if (n.is<language::do_while_statement>()) {
-    n.m_node_processor = std::make_unique<DoWhileStatement>(n);
+    n.m_node_processor = std::make_unique<DoWhileProcessor>(n);
   } else if (n.is<language::while_statement>()) {
-    n.m_node_processor = std::make_unique<WhileStatement>(n);
+    n.m_node_processor = std::make_unique<WhileProcessor>(n);
   } else if (n.is<language::for_statement>()) {
-    n.m_node_processor = std::make_unique<ForStatement>(n);
+    n.m_node_processor = std::make_unique<ForProcessor>(n);
   } else if (n.is<language::for_statement_bloc>()) {
-    n.m_node_processor = std::make_unique<ASTNodeList>(n);
+    n.m_node_processor = std::make_unique<ASTNodeListProcessor>(n);
   } else if (n.is<language::for_init>()) {
-    n.m_node_processor = std::make_unique<NoProcess>();
+    n.m_node_processor = std::make_unique<FakeProcessor>();
   } else if (n.is<language::for_post>()) {
-    n.m_node_processor = std::make_unique<NoProcess>();
+    n.m_node_processor = std::make_unique<FakeProcessor>();
   } else if (n.is<language::for_test>()) {
-    n.m_node_processor = std::make_unique<NoProcess>();
+    n.m_node_processor = std::make_unique<FakeProcessor>();
   } else if (n.is<language::break_kw>()) {
-    n.m_node_processor = std::make_unique<BreakExpression>();
+    n.m_node_processor = std::make_unique<BreakProcessor>();
   } else if (n.is<language::continue_kw>()) {
-    n.m_node_processor = std::make_unique<ContinueExpression>();
+    n.m_node_processor = std::make_unique<ContinueProcessor>();
   } else {
     std::ostringstream error_message;
     error_message << "undefined node type '" << rang::fgB::red << n.name() << rang::fg::reset << "'";
@@ -400,7 +400,7 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
 ASTNodeExpressionBuilder::ASTNodeExpressionBuilder(ASTNode& n)
 {
   Assert(n.is_root());
-  n.m_node_processor = std::make_unique<ASTNodeList>(n);
+  n.m_node_processor = std::make_unique<ASTNodeListProcessor>(n);
   for (auto& child : n.children) {
     this->_buildExpression(*child);
   }
diff --git a/tests/test_ASTNodeExpressionBuilder.cpp b/tests/test_ASTNodeExpressionBuilder.cpp
index f1ca3f8ab8402658bf70494ab83c41b082cf9865..69ca4625e1743b8c44466591964c658feedc8683 100644
--- a/tests/test_ASTNodeExpressionBuilder.cpp
+++ b/tests/test_ASTNodeExpressionBuilder.cpp
@@ -49,7 +49,7 @@ TEST_CASE("ASTNodeExpressionBuilder", "[language]")
 )";
 
     std::string_view result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
 )";
 
     CHECK_AST(data, result);
@@ -64,8 +64,8 @@ TEST_CASE("ASTNodeExpressionBuilder", "[language]")
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::integer:3:NoProcess)
+(root:ASTNodeListProcessor)
+ `-(language::integer:3:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -78,8 +78,8 @@ TEST_CASE("ASTNodeExpressionBuilder", "[language]")
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::real:2.3e-5:NoProcess)
+(root:ASTNodeListProcessor)
+ `-(language::real:2.3e-5:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -92,8 +92,8 @@ TEST_CASE("ASTNodeExpressionBuilder", "[language]")
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::literal:"foo":NoProcess)
+(root:ASTNodeListProcessor)
+ `-(language::literal:"foo":FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -106,8 +106,8 @@ true;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::true_kw:NoProcess)
+(root:ASTNodeListProcessor)
+ `-(language::true_kw:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -120,8 +120,8 @@ false;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::false_kw:NoProcess)
+(root:ASTNodeListProcessor)
+ `-(language::false_kw:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -137,9 +137,9 @@ false;
 )";
 
     std::string result = R"(
-(root:ASTNodeList)
- `-(language::bloc:ASTNodeList)
-     `-(language::integer:1:NoProcess)
+(root:ASTNodeListProcessor)
+ `-(language::bloc:ASTNodeListProcessor)
+     `-(language::integer:1:FakeProcessor)
 )";
 
     CHECK_AST(data, result);
@@ -153,8 +153,8 @@ i;
 )";
 
     std::string result = R"(
-(root:ASTNodeList)
- `-(language::name:i:NameExpression)
+(root:ASTNodeListProcessor)
+ `-(language::name:i:NameProcessor)
 )";
 
     CHECK_AST(data, result);
@@ -169,10 +169,10 @@ N i = 1;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
-     +-(language::name:i:NameExpression)
-     `-(language::integer:1:NoProcess)
+     +-(language::name:i:NameProcessor)
+     `-(language::integer:1:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -186,13 +186,13 @@ i *= 3;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
- |   +-(language::name:i:NameExpression)
- |   `-(language::integer:1:NoProcess)
+ |   +-(language::name:i:NameProcessor)
+ |   `-(language::integer:1:FakeProcessor)
  `-(language::multiplyeq_op:AffectationProcessor<language::multiplyeq_op, unsigned long, long>)
-     +-(language::name:i:NameExpression)
-     `-(language::integer:3:NoProcess)
+     +-(language::name:i:NameProcessor)
+     `-(language::integer:3:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -206,13 +206,13 @@ x /= 2;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, double, long>)
- |   +-(language::name:x:NameExpression)
- |   `-(language::integer:1:NoProcess)
+ |   +-(language::name:x:NameProcessor)
+ |   `-(language::integer:1:FakeProcessor)
  `-(language::divideeq_op:AffectationProcessor<language::divideeq_op, double, long>)
-     +-(language::name:x:NameExpression)
-     `-(language::integer:2:NoProcess)
+     +-(language::name:x:NameProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -226,13 +226,13 @@ i += 3.;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
- |   +-(language::name:i:NameExpression)
- |   `-(language::integer:1:NoProcess)
+ |   +-(language::name:i:NameProcessor)
+ |   `-(language::integer:1:FakeProcessor)
  `-(language::pluseq_op:AffectationProcessor<language::pluseq_op, unsigned long, double>)
-     +-(language::name:i:NameExpression)
-     `-(language::real:3.:NoProcess)
+     +-(language::name:i:NameProcessor)
+     `-(language::real:3.:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -246,13 +246,13 @@ z -= 2;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
- |   +-(language::name:z:NameExpression)
- |   `-(language::integer:1:NoProcess)
+ |   +-(language::name:z:NameProcessor)
+ |   `-(language::integer:1:FakeProcessor)
  `-(language::minuseq_op:AffectationProcessor<language::minuseq_op, long, long>)
-     +-(language::name:z:NameExpression)
-     `-(language::integer:2:NoProcess)
+     +-(language::name:z:NameProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -268,9 +268,9 @@ z -= 2;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
-     `-(language::integer:1:NoProcess)
+     `-(language::integer:1:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -283,9 +283,9 @@ not 1;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::unary_not:UnaryExpressionProcessor<language::unary_not, bool, long>)
-     `-(language::integer:1:NoProcess)
+     `-(language::integer:1:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -299,12 +299,12 @@ Z a=1;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
- |   +-(language::name:a:NameExpression)
- |   `-(language::integer:1:NoProcess)
+ |   +-(language::name:a:NameProcessor)
+ |   `-(language::integer:1:FakeProcessor)
  `-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, long, long>)
-     `-(language::name:a:NameExpression)
+     `-(language::name:a:NameProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -318,12 +318,12 @@ Z a=1;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
- |   +-(language::name:a:NameExpression)
- |   `-(language::integer:1:NoProcess)
+ |   +-(language::name:a:NameProcessor)
+ |   `-(language::integer:1:FakeProcessor)
  `-(language::unary_minusminus:IncDecExpressionProcessor<language::unary_minusminus, long, long>)
-     `-(language::name:a:NameExpression)
+     `-(language::name:a:NameProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -337,12 +337,12 @@ a++;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
- |   +-(language::name:a:NameExpression)
- |   `-(language::integer:1:NoProcess)
+ |   +-(language::name:a:NameProcessor)
+ |   `-(language::integer:1:FakeProcessor)
  `-(language::post_plusplus:IncDecExpressionProcessor<language::post_plusplus, long, long>)
-     `-(language::name:a:NameExpression)
+     `-(language::name:a:NameProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -356,12 +356,12 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, long, long>)
- |   +-(language::name:a:NameExpression)
- |   `-(language::integer:1:NoProcess)
+ |   +-(language::name:a:NameProcessor)
+ |   `-(language::integer:1:FakeProcessor)
  `-(language::post_minusminus:IncDecExpressionProcessor<language::post_minusminus, long, long>)
-     `-(language::name:a:NameExpression)
+     `-(language::name:a:NameProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -377,10 +377,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -393,10 +393,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::divide_op:BinaryExpressionProcessor<language::divide_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -409,10 +409,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::plus_op:BinaryExpressionProcessor<language::plus_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -425,10 +425,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::minus_op:BinaryExpressionProcessor<language::minus_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -441,10 +441,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::or_op:BinaryExpressionProcessor<language::or_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -457,10 +457,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::and_op:BinaryExpressionProcessor<language::and_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -473,10 +473,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::xor_op:BinaryExpressionProcessor<language::xor_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -489,10 +489,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::lesser_op:BinaryExpressionProcessor<language::lesser_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -505,10 +505,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::lesser_or_eq_op:BinaryExpressionProcessor<language::lesser_or_eq_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -521,10 +521,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::greater_op:BinaryExpressionProcessor<language::greater_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -537,10 +537,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::greater_or_eq_op:BinaryExpressionProcessor<language::greater_or_eq_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -553,10 +553,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::eqeq_op:BinaryExpressionProcessor<language::eqeq_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -569,10 +569,10 @@ a--;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  `-(language::not_eq_op:BinaryExpressionProcessor<language::not_eq_op, long, long>)
-     +-(language::integer:1:NoProcess)
-     `-(language::integer:2:NoProcess)
+     +-(language::integer:1:FakeProcessor)
+     `-(language::integer:2:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -588,8 +588,8 @@ cout;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::cout_kw:OStreamObject)
+(root:ASTNodeListProcessor)
+ `-(language::cout_kw:OStreamProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -602,8 +602,8 @@ cerr;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::cerr_kw:OStreamObject)
+(root:ASTNodeListProcessor)
+ `-(language::cerr_kw:OStreamProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -616,8 +616,8 @@ clog;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::clog_kw:OStreamObject)
+(root:ASTNodeListProcessor)
+ `-(language::clog_kw:OStreamProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -633,10 +633,10 @@ if(true);
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::if_statement:IfStatement)
-     +-(language::true_kw:NoProcess)
-     `-(language::statement_bloc:ASTNodeList)
+(root:ASTNodeListProcessor)
+ `-(language::if_statement:IfProcessor)
+     +-(language::true_kw:FakeProcessor)
+     `-(language::statement_bloc:ASTNodeListProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -649,10 +649,10 @@ do; while(true);
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::do_while_statement:DoWhileStatement)
-     +-(language::statement_bloc:ASTNodeList)
-     `-(language::true_kw:NoProcess)
+(root:ASTNodeListProcessor)
+ `-(language::do_while_statement:DoWhileProcessor)
+     +-(language::statement_bloc:ASTNodeListProcessor)
+     `-(language::true_kw:FakeProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -665,10 +665,10 @@ while(true);
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::while_statement:WhileStatement)
-     +-(language::true_kw:NoProcess)
-     `-(language::statement_bloc:ASTNodeList)
+(root:ASTNodeListProcessor)
+ `-(language::while_statement:WhileProcessor)
+     +-(language::true_kw:FakeProcessor)
+     `-(language::statement_bloc:ASTNodeListProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -683,17 +683,17 @@ for(N i=0; i<10; ++i);
 )";
 
         std::string result = R"(
-(root:ASTNodeList)
- `-(language::for_statement:ForStatement)
+(root:ASTNodeListProcessor)
+ `-(language::for_statement:ForProcessor)
      +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
-     |   +-(language::name:i:NameExpression)
-     |   `-(language::integer:0:NoProcess)
+     |   +-(language::name:i:NameProcessor)
+     |   `-(language::integer:0:FakeProcessor)
      +-(language::lesser_op:BinaryExpressionProcessor<language::lesser_op, unsigned long, long>)
-     |   +-(language::name:i:NameExpression)
-     |   `-(language::integer:10:NoProcess)
+     |   +-(language::name:i:NameProcessor)
+     |   `-(language::integer:10:FakeProcessor)
      +-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, unsigned long, unsigned long>)
-     |   `-(language::name:i:NameExpression)
-     `-(language::for_statement_bloc:ASTNodeList)
+     |   `-(language::name:i:NameProcessor)
+     `-(language::for_statement_bloc:ASTNodeListProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -707,18 +707,18 @@ for(; i<10; ++i);
 )";
 
         std::string result = R"(
-(root:ASTNodeList)
+(root:ASTNodeListProcessor)
  +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
- |   +-(language::name:i:NameExpression)
- |   `-(language::integer:0:NoProcess)
- `-(language::for_statement:ForStatement)
-     +-(language::for_init:NoProcess)
+ |   +-(language::name:i:NameProcessor)
+ |   `-(language::integer:0:FakeProcessor)
+ `-(language::for_statement:ForProcessor)
+     +-(language::for_init:FakeProcessor)
      +-(language::lesser_op:BinaryExpressionProcessor<language::lesser_op, unsigned long, long>)
-     |   +-(language::name:i:NameExpression)
-     |   `-(language::integer:10:NoProcess)
+     |   +-(language::name:i:NameProcessor)
+     |   `-(language::integer:10:FakeProcessor)
      +-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, unsigned long, unsigned long>)
-     |   `-(language::name:i:NameExpression)
-     `-(language::for_statement_bloc:ASTNodeList)
+     |   `-(language::name:i:NameProcessor)
+     `-(language::for_statement_bloc:ASTNodeListProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -731,15 +731,15 @@ for(N i=0; ; ++i);
 )";
 
         std::string result = R"(
-(root:ASTNodeList)
- `-(language::for_statement:ForStatement)
+(root:ASTNodeListProcessor)
+ `-(language::for_statement:ForProcessor)
      +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
-     |   +-(language::name:i:NameExpression)
-     |   `-(language::integer:0:NoProcess)
-     +-(language::for_test:NoProcess)
+     |   +-(language::name:i:NameProcessor)
+     |   `-(language::integer:0:FakeProcessor)
+     +-(language::for_test:FakeProcessor)
      +-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, unsigned long, unsigned long>)
-     |   `-(language::name:i:NameExpression)
-     `-(language::for_statement_bloc:ASTNodeList)
+     |   `-(language::name:i:NameProcessor)
+     `-(language::for_statement_bloc:ASTNodeListProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -752,16 +752,16 @@ for(N i=0; i<10;);
 )";
 
         std::string result = R"(
-(root:ASTNodeList)
- `-(language::for_statement:ForStatement)
+(root:ASTNodeListProcessor)
+ `-(language::for_statement:ForProcessor)
      +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
-     |   +-(language::name:i:NameExpression)
-     |   `-(language::integer:0:NoProcess)
+     |   +-(language::name:i:NameProcessor)
+     |   `-(language::integer:0:FakeProcessor)
      +-(language::lesser_op:BinaryExpressionProcessor<language::lesser_op, unsigned long, long>)
-     |   +-(language::name:i:NameExpression)
-     |   `-(language::integer:10:NoProcess)
-     +-(language::for_post:NoProcess)
-     `-(language::for_statement_bloc:ASTNodeList)
+     |   +-(language::name:i:NameProcessor)
+     |   `-(language::integer:10:FakeProcessor)
+     +-(language::for_post:FakeProcessor)
+     `-(language::for_statement_bloc:ASTNodeListProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -778,8 +778,8 @@ break;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::break_kw:BreakExpression)
+(root:ASTNodeListProcessor)
+ `-(language::break_kw:BreakProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -792,8 +792,8 @@ continue;
 )";
 
       std::string result = R"(
-(root:ASTNodeList)
- `-(language::continue_kw:ContinueExpression)
+(root:ASTNodeListProcessor)
+ `-(language::continue_kw:ContinueProcessor)
 )";
 
       CHECK_AST(data, result);