diff --git a/src/language/ASTNode.hpp b/src/language/ASTNode.hpp
index 4b1886a660b97e658675e8620c513716a6d490cb..80f47e696d2e50ce8fcdb40131326cd9770d8ce9 100644
--- a/src/language/ASTNode.hpp
+++ b/src/language/ASTNode.hpp
@@ -66,9 +66,6 @@ class SymbolTable;
 
 struct ASTNode : public parse_tree::basic_node<ASTNode>
 {
-  using DataType    = language::DataType;
-  using DataVariant = language::DataVariant;
-
   std::shared_ptr<SymbolTable> m_symbol_table;
   std::unique_ptr<INodeProcessor> m_node_processor;
 
@@ -82,8 +79,8 @@ struct ASTNode : public parse_tree::basic_node<ASTNode>
     }
   }
 
-  DataType m_data_type{DataType::undefined_t};
-  DataVariant m_value;
+  ASTNodeDataType m_data_type{ASTNodeDataType::undefined_t};
+  ASTNodeDataVariant m_value;
 };
 
 #endif   // AST_NODE_HPP
diff --git a/src/language/ASTNodeAffectationExpressionBuilder.cpp b/src/language/ASTNodeAffectationExpressionBuilder.cpp
index 498ca65add907a9ed0d83c4c5c0904398c680246..d6aefe532085e3240b3d24525c492b795159c3a2 100644
--- a/src/language/ASTNodeAffectationExpressionBuilder.cpp
+++ b/src/language/ASTNodeAffectationExpressionBuilder.cpp
@@ -100,7 +100,7 @@ class AffectationProcessor final : public INodeProcessor
 {
  private:
   ASTNode& m_node;
-  DataVariant* p_value{nullptr};
+  ASTNodeDataVariant* p_value{nullptr};
 
   static inline const bool _is_defined{[] {
     if constexpr (std::is_same_v<OperatorT, language::bit_andeq_op> or
@@ -152,7 +152,7 @@ class AffectationToStringProcessor final : public INodeProcessor
 {
  private:
   ASTNode& m_node;
-  DataVariant* p_value{nullptr};
+  ASTNodeDataVariant* p_value{nullptr};
 
   static inline const bool _is_defined{[] {
     if constexpr (std::is_same_v<OperatorT, language::bit_andeq_op> or
@@ -202,23 +202,23 @@ class AffectationToStringProcessor final : public INodeProcessor
 ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode& n)
 {
   auto set_affectation_processor = [](ASTNode& n, const auto& operator_v) {
-    auto set_affectation_processor_for_data = [&](const auto& value, const DataType& data_type) {
+    auto set_affectation_processor_for_data = [&](const auto& value, const ASTNodeDataType& data_type) {
       using OperatorT = std::decay_t<decltype(operator_v)>;
       using ValueT    = std::decay_t<decltype(value)>;
       switch (data_type) {
-      case DataType::bool_t: {
+      case ASTNodeDataType::bool_t: {
         n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, bool>>(n);
         break;
       }
-      case DataType::unsigned_int_t: {
+      case ASTNodeDataType::unsigned_int_t: {
         n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, uint64_t>>(n);
         break;
       }
-      case DataType::int_t: {
+      case ASTNodeDataType::int_t: {
         n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, int64_t>>(n);
         break;
       }
-      case DataType::double_t: {
+      case ASTNodeDataType::double_t: {
         n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, double>>(n);
         break;
       }
@@ -228,28 +228,28 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
       }
     };
 
-    auto set_affectation_processor_for_string_data = [&](const DataType& data_type) {
+    auto set_affectation_processor_for_string_data = [&](const ASTNodeDataType& data_type) {
       using OperatorT = std::decay_t<decltype(operator_v)>;
 
       if constexpr (std::is_same_v<OperatorT, language::eq_op> or std::is_same_v<OperatorT, language::pluseq_op>) {
         switch (data_type) {
-        case DataType::bool_t: {
+        case ASTNodeDataType::bool_t: {
           n.m_node_processor = std::make_unique<AffectationToStringProcessor<OperatorT, bool>>(n);
           break;
         }
-        case DataType::unsigned_int_t: {
+        case ASTNodeDataType::unsigned_int_t: {
           n.m_node_processor = std::make_unique<AffectationToStringProcessor<OperatorT, uint64_t>>(n);
           break;
         }
-        case DataType::int_t: {
+        case ASTNodeDataType::int_t: {
           n.m_node_processor = std::make_unique<AffectationToStringProcessor<OperatorT, int64_t>>(n);
           break;
         }
-        case DataType::double_t: {
+        case ASTNodeDataType::double_t: {
           n.m_node_processor = std::make_unique<AffectationToStringProcessor<OperatorT, double>>(n);
           break;
         }
-        case DataType::string_t: {
+        case ASTNodeDataType::string_t: {
           n.m_node_processor = std::make_unique<AffectationToStringProcessor<OperatorT, std::string>>(n);
           break;
         }
@@ -262,26 +262,26 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
       }
     };
 
-    auto set_affectation_processor_for_value = [&](const DataType& value_type) {
-      const DataType data_type = n.children[1]->m_data_type;
+    auto set_affectation_processor_for_value = [&](const ASTNodeDataType& value_type) {
+      const ASTNodeDataType data_type = n.children[1]->m_data_type;
       switch (value_type) {
-      case DataType::bool_t: {
+      case ASTNodeDataType::bool_t: {
         set_affectation_processor_for_data(bool{}, data_type);
         break;
       }
-      case DataType::unsigned_int_t: {
+      case ASTNodeDataType::unsigned_int_t: {
         set_affectation_processor_for_data(uint64_t{}, data_type);
         break;
       }
-      case DataType::int_t: {
+      case ASTNodeDataType::int_t: {
         set_affectation_processor_for_data(int64_t{}, data_type);
         break;
       }
-      case DataType::double_t: {
+      case ASTNodeDataType::double_t: {
         set_affectation_processor_for_data(double{}, data_type);
         break;
       }
-      case DataType::string_t: {
+      case ASTNodeDataType::string_t: {
         set_affectation_processor_for_string_data(data_type);
         break;
       }
diff --git a/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp b/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp
index ab3fe55db391f1605aaae5f4d80390acb127f1fe..8d710ac11005f59b3fc37862f5d9c7eac2fd996c 100644
--- a/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp
+++ b/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp
@@ -180,7 +180,7 @@ class BinaryExpressionProcessor final : public INodeProcessor
   ASTNode& m_node;
 
   PUGS_INLINE auto
-  eval(const DataVariant& a, const DataVariant& b, DataVariant& value)
+  eval(const ASTNodeDataVariant& a, const ASTNodeDataVariant& b, ASTNodeDataVariant& value)
   {
     // Add 'signed' when necessary to avoid signed/unsigned comparison warnings
     if constexpr ((not(std::is_same_v<A_DataT, bool> or std::is_same_v<B_DataT, bool>)) and
@@ -242,23 +242,23 @@ class BinaryExpressionProcessor final : public INodeProcessor
 ASTNodeBinaryOperatorExpressionBuilder::ASTNodeBinaryOperatorExpressionBuilder(ASTNode& n)
 {
   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) {
+    auto set_binary_operator_processor_for_data_b = [&](const auto data_a, const ASTNodeDataType& data_type_b) {
       using OperatorT = std::decay_t<decltype(operator_v)>;
       using DataTA    = std::decay_t<decltype(data_a)>;
       switch (data_type_b) {
-      case DataType::bool_t: {
+      case ASTNodeDataType::bool_t: {
         n.m_node_processor = std::make_unique<BinaryExpressionProcessor<OperatorT, DataTA, bool>>(n);
         break;
       }
-      case DataType::unsigned_int_t: {
+      case ASTNodeDataType::unsigned_int_t: {
         n.m_node_processor = std::make_unique<BinaryExpressionProcessor<OperatorT, DataTA, uint64_t>>(n);
         break;
       }
-      case DataType::int_t: {
+      case ASTNodeDataType::int_t: {
         n.m_node_processor = std::make_unique<BinaryExpressionProcessor<OperatorT, DataTA, int64_t>>(n);
         break;
       }
-      case DataType::double_t: {
+      case ASTNodeDataType::double_t: {
         n.m_node_processor = std::make_unique<BinaryExpressionProcessor<OperatorT, DataTA, double>>(n);
         break;
       }
@@ -268,22 +268,22 @@ ASTNodeBinaryOperatorExpressionBuilder::ASTNodeBinaryOperatorExpressionBuilder(A
       }
     };
 
-    auto set_binary_operator_processor_for_data_a = [&](const DataType& data_type_a) {
-      const DataType data_type_b = n.children[1]->m_data_type;
+    auto set_binary_operator_processor_for_data_a = [&](const ASTNodeDataType& data_type_a) {
+      const ASTNodeDataType data_type_b = n.children[1]->m_data_type;
       switch (data_type_a) {
-      case DataType::bool_t: {
+      case ASTNodeDataType::bool_t: {
         set_binary_operator_processor_for_data_b(bool{}, data_type_b);
         break;
       }
-      case DataType::unsigned_int_t: {
+      case ASTNodeDataType::unsigned_int_t: {
         set_binary_operator_processor_for_data_b(uint64_t{}, data_type_b);
         break;
       }
-      case DataType::int_t: {
+      case ASTNodeDataType::int_t: {
         set_binary_operator_processor_for_data_b(int64_t{}, data_type_b);
         break;
       }
-      case DataType::double_t: {
+      case ASTNodeDataType::double_t: {
         set_binary_operator_processor_for_data_b(double{}, data_type_b);
         break;
       }
diff --git a/src/language/ASTNodeDataType.cpp b/src/language/ASTNodeDataType.cpp
index e5552d8db03fb52fa78a705cbcf4c6975fbe3e70..a6287f4c2c9c7d177554a9edc155b9d0ee958ecf 100644
--- a/src/language/ASTNodeDataType.cpp
+++ b/src/language/ASTNodeDataType.cpp
@@ -1,51 +1,47 @@
 #include <ASTNodeDataType.hpp>
 
-namespace language
-{
 std::string
-dataTypeName(const DataType& data_type)
+dataTypeName(const ASTNodeDataType& data_type)
 {
   std::string name;
   switch (data_type) {
-  case DataType::undefined_t:
+  case ASTNodeDataType::undefined_t:
     name = "undefined";
     break;
-  case DataType::bool_t:
+  case ASTNodeDataType::bool_t:
     name = "B";
     break;
-  case DataType::unsigned_int_t:
+  case ASTNodeDataType::unsigned_int_t:
     name = "N";
     break;
-  case DataType::int_t:
+  case ASTNodeDataType::int_t:
     name = "Z";
     break;
-  case DataType::double_t:
+  case ASTNodeDataType::double_t:
     name = "R";
     break;
-  case DataType::string_t:
+  case ASTNodeDataType::string_t:
     name = "string";
     break;
-  case DataType::typename_t:
+  case ASTNodeDataType::typename_t:
     name = "typename";
     break;
-  case DataType::void_t:
+  case ASTNodeDataType::void_t:
     name = "void";
     break;
   }
   return name;
 }
 
-DataType
-dataTypePromotion(const DataType& data_type_1, const DataType& data_type_2)
+ASTNodeDataType
+dataTypePromotion(const ASTNodeDataType& data_type_1, const ASTNodeDataType& data_type_2)
 {
   if (data_type_1 == data_type_2) {
     return data_type_1;
-  } else if ((std::max(data_type_1, data_type_2) <= DataType::double_t) and
-             (std::min(data_type_1, data_type_2) >= DataType::bool_t)) {
+  } else if ((std::max(data_type_1, data_type_2) <= ASTNodeDataType::double_t) and
+             (std::min(data_type_1, data_type_2) >= ASTNodeDataType::bool_t)) {
     return std::max(data_type_1, data_type_2);
   } else {
-    return DataType::undefined_t;
+    return ASTNodeDataType::undefined_t;
   }
 }
-
-}   // namespace language
diff --git a/src/language/ASTNodeDataType.hpp b/src/language/ASTNodeDataType.hpp
index 605f42524074cb9e35241c0407cc4f986dec2255..91714da952304e77f6a50291221d14a8fba2f615 100644
--- a/src/language/ASTNodeDataType.hpp
+++ b/src/language/ASTNodeDataType.hpp
@@ -4,9 +4,7 @@
 #include <string>
 #include <variant>
 
-namespace language
-{
-enum class DataType
+enum class ASTNodeDataType
 {
   undefined_t    = -1,
   bool_t         = 0,
@@ -18,12 +16,10 @@ enum class DataType
   void_t         = 9999
 };
 
-std::string dataTypeName(const DataType& data_type);
-
-DataType dataTypePromotion(const DataType& data_type_1, const DataType& data_type_2);
+std::string dataTypeName(const ASTNodeDataType& data_type);
 
-using DataVariant = std::variant<std::monostate, bool, uint64_t, int64_t, double, std::string>;
+ASTNodeDataType dataTypePromotion(const ASTNodeDataType& data_type_1, const ASTNodeDataType& data_type_2);
 
-}   // namespace language
+using ASTNodeDataVariant = std::variant<std::monostate, bool, uint64_t, int64_t, double, std::string>;
 
 #endif   // AST_NODE_DATATYPE_HPP
diff --git a/src/language/ASTNodeExpressionBuilder.cpp b/src/language/ASTNodeExpressionBuilder.cpp
index d97f15b9f1d7d347643272857c6e0445a09b66a4..fd6d3fca68b6abd1f25c8b7b0061f8cc11705d2c 100644
--- a/src/language/ASTNodeExpressionBuilder.cpp
+++ b/src/language/ASTNodeExpressionBuilder.cpp
@@ -187,7 +187,7 @@ class ForStatement final : public INodeProcessor
 class NameExpression final : public INodeProcessor
 {
   ASTNode& m_node;
-  DataVariant* p_value{nullptr};
+  ASTNodeDataVariant* p_value{nullptr};
 
  public:
   NameExpression(ASTNode& node) : m_node{node}
diff --git a/src/language/ASTNodeIncDecExpressionBuilder.cpp b/src/language/ASTNodeIncDecExpressionBuilder.cpp
index 6cc21aa29e9f88be315b8595604723fbf6a2d7f1..fac93f761edadd0b5dc1bf8424a048d47ef554a6 100644
--- a/src/language/ASTNodeIncDecExpressionBuilder.cpp
+++ b/src/language/ASTNodeIncDecExpressionBuilder.cpp
@@ -55,7 +55,7 @@ template <typename IncDecOpT, typename ValueT, typename DataT>
 class IncDecExpressionProcessor final : public INodeProcessor
 {
   ASTNode& m_node;
-  DataVariant* p_value{nullptr};
+  ASTNodeDataVariant* p_value{nullptr};
 
   static inline const bool _is_defined{[] {
     if constexpr (std::is_same_v<IncDecOpT, language::unary_minusminus> or
@@ -93,23 +93,23 @@ class IncDecExpressionProcessor final : public INodeProcessor
 ASTNodeIncDecExpressionBuilder::ASTNodeIncDecExpressionBuilder(ASTNode& n)
 {
   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) {
+    auto set_inc_dec_operator_processor_for_data = [&](const auto& value, const ASTNodeDataType& data_type) {
       using OperatorT = std::decay_t<decltype(operator_v)>;
       using ValueT    = std::decay_t<decltype(value)>;
       switch (data_type) {
-      case DataType::bool_t: {
+      case ASTNodeDataType::bool_t: {
         n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, ValueT, bool>>(n);
         break;
       }
-      case DataType::unsigned_int_t: {
+      case ASTNodeDataType::unsigned_int_t: {
         n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, ValueT, uint64_t>>(n);
         break;
       }
-      case DataType::int_t: {
+      case ASTNodeDataType::int_t: {
         n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, ValueT, int64_t>>(n);
         break;
       }
-      case DataType::double_t: {
+      case ASTNodeDataType::double_t: {
         n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, ValueT, double>>(n);
         break;
       }
@@ -119,22 +119,22 @@ ASTNodeIncDecExpressionBuilder::ASTNodeIncDecExpressionBuilder(ASTNode& n)
       }
     };
 
-    auto set_inc_dec_processor_for_value = [&](const DataType& value_type) {
-      const DataType data_type = n.children[0]->m_data_type;
+    auto set_inc_dec_processor_for_value = [&](const ASTNodeDataType& value_type) {
+      const ASTNodeDataType data_type = n.children[0]->m_data_type;
       switch (value_type) {
-      case DataType::bool_t: {
+      case ASTNodeDataType::bool_t: {
         set_inc_dec_operator_processor_for_data(bool{}, data_type);
         break;
       }
-      case DataType::unsigned_int_t: {
+      case ASTNodeDataType::unsigned_int_t: {
         set_inc_dec_operator_processor_for_data(uint64_t{}, data_type);
         break;
       }
-      case DataType::int_t: {
+      case ASTNodeDataType::int_t: {
         set_inc_dec_operator_processor_for_data(int64_t{}, data_type);
         break;
       }
-      case DataType::double_t: {
+      case ASTNodeDataType::double_t: {
         set_inc_dec_operator_processor_for_data(double{}, data_type);
         break;
       }
diff --git a/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp b/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp
index 491079f573930dcc5d48bbf0991cb323512ffeeb..60160b95e697213388f8c06efb672d53f9f0f25e 100644
--- a/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp
+++ b/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp
@@ -36,7 +36,7 @@ class UnaryExpressionProcessor final : public INodeProcessor
 
  public:
   PUGS_INLINE ValueT
-  eval(const DataVariant& a)
+  eval(const ASTNodeDataVariant& a)
   {
     return UnaryOp<UnaryOpT>().eval(std::get<DataT>(a));
   }
@@ -55,23 +55,23 @@ class UnaryExpressionProcessor final : public INodeProcessor
 ASTNodeUnaryOperatorExpressionBuilder::ASTNodeUnaryOperatorExpressionBuilder(ASTNode& n)
 {
   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) {
+    auto set_unary_operator_processor_for_data = [&](const auto& value, const ASTNodeDataType& data_type) {
       using OperatorT = std::decay_t<decltype(operator_v)>;
       using ValueT    = std::decay_t<decltype(value)>;
       switch (data_type) {
-      case DataType::bool_t: {
+      case ASTNodeDataType::bool_t: {
         n.m_node_processor = std::make_unique<UnaryExpressionProcessor<OperatorT, ValueT, bool>>(n);
         break;
       }
-      case DataType::unsigned_int_t: {
+      case ASTNodeDataType::unsigned_int_t: {
         n.m_node_processor = std::make_unique<UnaryExpressionProcessor<OperatorT, ValueT, uint64_t>>(n);
         break;
       }
-      case DataType::int_t: {
+      case ASTNodeDataType::int_t: {
         n.m_node_processor = std::make_unique<UnaryExpressionProcessor<OperatorT, ValueT, int64_t>>(n);
         break;
       }
-      case DataType::double_t: {
+      case ASTNodeDataType::double_t: {
         n.m_node_processor = std::make_unique<UnaryExpressionProcessor<OperatorT, ValueT, double>>(n);
         break;
       }
@@ -81,22 +81,22 @@ ASTNodeUnaryOperatorExpressionBuilder::ASTNodeUnaryOperatorExpressionBuilder(AST
       }
     };
 
-    auto set_unary_operator_processor_for_value = [&](const DataType& value_type) {
-      const DataType data_type = n.children[0]->m_data_type;
+    auto set_unary_operator_processor_for_value = [&](const ASTNodeDataType& value_type) {
+      const ASTNodeDataType data_type = n.children[0]->m_data_type;
       switch (value_type) {
-      case DataType::bool_t: {
+      case ASTNodeDataType::bool_t: {
         set_unary_operator_processor_for_data(bool{}, data_type);
         break;
       }
-      case DataType::unsigned_int_t: {
+      case ASTNodeDataType::unsigned_int_t: {
         set_unary_operator_processor_for_data(uint64_t{}, data_type);
         break;
       }
-      case DataType::int_t: {
+      case ASTNodeDataType::int_t: {
         set_unary_operator_processor_for_data(int64_t{}, data_type);
         break;
       }
-      case DataType::double_t: {
+      case ASTNodeDataType::double_t: {
         set_unary_operator_processor_for_data(double{}, data_type);
         break;
       }
diff --git a/src/language/ASTPrinter.cpp b/src/language/ASTPrinter.cpp
index aab87af9ead8c199a2cf6f3ad270044e3d025d9c..3f5b7344aaeb979becfa81875db39257bb85636b 100644
--- a/src/language/ASTPrinter.cpp
+++ b/src/language/ASTPrinter.cpp
@@ -3,8 +3,6 @@
 
 #include <PEGGrammar.hpp>
 
-namespace language
-{
 void
 ASTPrinter::_print(std::ostream& os, const ASTNode& node) const
 {
@@ -105,4 +103,3 @@ ASTPrinter::ASTPrinter(const ASTNode& node, Format format, std::initializer_list
     m_info |= static_cast<InfoBaseType>(i);
   }
 }
-}   // namespace language
diff --git a/src/language/ASTPrinter.hpp b/src/language/ASTPrinter.hpp
index 4d731c840db934f4249101c5a0cd002ae961876c..464a67435c88a028254f8b52c59bb6f4005b4e2f 100644
--- a/src/language/ASTPrinter.hpp
+++ b/src/language/ASTPrinter.hpp
@@ -3,8 +3,6 @@
 
 #include <ASTNode.hpp>
 
-namespace language
-{
 class ASTPrinter
 {
  public:
@@ -56,5 +54,5 @@ class ASTPrinter
 
   ~ASTPrinter() = default;
 };
-}   // namespace language
+
 #endif   // AST_PRINTER_HPP
diff --git a/src/language/PugsParser.cpp b/src/language/PugsParser.cpp
index d2d3c89102289daca1680926edf11d16eee70d9d..fcd2261c291207a8e7c2f8c7e606fa09e196b9dc 100644
--- a/src/language/PugsParser.cpp
+++ b/src/language/PugsParser.cpp
@@ -138,37 +138,37 @@ build_node_data_types(ASTNode& n)
         build_node_data_types(*child);
       }
     }
-    n.m_data_type = DataType::void_t;
+    n.m_data_type = ASTNodeDataType::void_t;
   } else {
     if (n.has_content()) {
       if (n.is<language::true_kw>() or n.is<language::false_kw>() or n.is<language::do_kw>()) {
-        n.m_data_type = DataType::bool_t;
+        n.m_data_type = ASTNodeDataType::bool_t;
       } else if (n.is<language::real>()) {
-        n.m_data_type = DataType::double_t;
+        n.m_data_type = ASTNodeDataType::double_t;
       } else if (n.is<language::integer>()) {
-        n.m_data_type = DataType::int_t;
+        n.m_data_type = ASTNodeDataType::int_t;
       } else if (n.is<language::literal>()) {
-        n.m_data_type = DataType::string_t;
+        n.m_data_type = ASTNodeDataType::string_t;
       } else if (n.is<language::cout_kw>() or n.is<language::cerr_kw>() or n.is<language::clog_kw>()) {
-        n.m_data_type = DataType::void_t;
+        n.m_data_type = ASTNodeDataType::void_t;
       } else if (n.is<language::declaration>()) {
         auto& type_node = *(n.children[0]);
-        DataType data_type{DataType::undefined_t};
+        ASTNodeDataType data_type{ASTNodeDataType::undefined_t};
         if (type_node.is<language::B_set>()) {
-          data_type = DataType::bool_t;
+          data_type = ASTNodeDataType::bool_t;
         } else if (type_node.is<language::Z_set>()) {
-          data_type = DataType::int_t;
+          data_type = ASTNodeDataType::int_t;
         } else if (type_node.is<language::N_set>()) {
-          data_type = DataType::unsigned_int_t;
+          data_type = ASTNodeDataType::unsigned_int_t;
         } else if (type_node.is<language::R_set>()) {
-          data_type = DataType::double_t;
+          data_type = ASTNodeDataType::double_t;
         } else if (type_node.is<language::string_type>()) {
-          data_type = DataType::string_t;
+          data_type = ASTNodeDataType::string_t;
         }
-        if (data_type == DataType::undefined_t) {
+        if (data_type == ASTNodeDataType::undefined_t) {
           throw parse_error("unexpected error: invalid datatype", type_node.begin());
         }
-        type_node.m_data_type      = DataType::void_t;
+        type_node.m_data_type      = ASTNodeDataType::void_t;
         n.children[1]->m_data_type = data_type;
         const std::string& symbol  = n.children[1]->string();
 
@@ -191,23 +191,24 @@ build_node_data_types(ASTNode& n)
     }
 
     if (n.is<language::break_kw>() or n.is<language::continue_kw>()) {
-      n.m_data_type = DataType::void_t;
+      n.m_data_type = ASTNodeDataType::void_t;
     } 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>() or n.is<language::bit_andeq_op>() or
                n.is<language::bit_xoreq_op>() or n.is<language::bit_oreq_op>()) {
       n.m_data_type = n.children[0]->m_data_type;
     } else if (n.is<language::for_statement>()) {
-      n.m_data_type = DataType::void_t;
+      n.m_data_type = ASTNodeDataType::void_t;
     } else if (n.is<language::for_post>() or n.is<language::for_init>() or n.is<language::for_statement_bloc>()) {
-      n.m_data_type = DataType::void_t;
+      n.m_data_type = ASTNodeDataType::void_t;
     } else if (n.is<language::for_test>()) {
-      n.m_data_type = DataType::bool_t;
+      n.m_data_type = ASTNodeDataType::bool_t;
     } else if (n.is<language::statement_bloc>()) {
-      n.m_data_type = DataType::void_t;
+      n.m_data_type = ASTNodeDataType::void_t;
     } else if (n.is<language::if_statement>() or n.is<language::while_statement>()) {
-      n.m_data_type = DataType::void_t;
-      if ((n.children[0]->m_data_type > DataType::double_t) or (n.children[0]->m_data_type < DataType::bool_t)) {
-        const DataType type_0 = n.children[0]->m_data_type;
+      n.m_data_type = ASTNodeDataType::void_t;
+      if ((n.children[0]->m_data_type > ASTNodeDataType::double_t) or
+          (n.children[0]->m_data_type < ASTNodeDataType::bool_t)) {
+        const ASTNodeDataType type_0 = n.children[0]->m_data_type;
         std::ostringstream message;
         message << "Cannot convert data type to boolean value\n"
                 << "note: incompatible operand '" << n.children[0]->string() << " of type ' (" << dataTypeName(type_0)
@@ -215,9 +216,10 @@ build_node_data_types(ASTNode& n)
         throw parse_error(message.str(), n.children[0]->begin());
       }
     } else if (n.is<language::do_while_statement>()) {
-      n.m_data_type = DataType::void_t;
-      if ((n.children[1]->m_data_type > DataType::double_t) or (n.children[1]->m_data_type < DataType::bool_t)) {
-        const DataType type_0 = n.children[1]->m_data_type;
+      n.m_data_type = ASTNodeDataType::void_t;
+      if ((n.children[1]->m_data_type > ASTNodeDataType::double_t) or
+          (n.children[1]->m_data_type < ASTNodeDataType::bool_t)) {
+        const ASTNodeDataType type_0 = n.children[1]->m_data_type;
         std::ostringstream message;
         message << "Cannot convert data type to boolean value\n"
                 << "note: incompatible operand '" << n.children[1]->string() << " of type ' (" << dataTypeName(type_0)
@@ -228,17 +230,17 @@ build_node_data_types(ASTNode& n)
                n.is<language::greater_op>() or n.is<language::greater_or_eq_op>() or n.is<language::eqeq_op>() or
                n.is<language::not_eq_op>() or n.is<language::and_op>() or n.is<language::or_op>() or
                n.is<language::xor_op>() or n.is<language::bitand_op>() or n.is<language::bitor_op>()) {
-      n.m_data_type = DataType::bool_t;
+      n.m_data_type = ASTNodeDataType::bool_t;
     } else if (n.is<language::unary_minus>() or n.is<language::unary_plus>() or n.is<language::unary_plusplus>() or
                n.is<language::unary_minusminus>()) {
       n.m_data_type = n.children[0]->m_data_type;
     } else if (n.is<language::plus_op>() or n.is<language::minus_op>() or n.is<language::multiply_op>() or
                n.is<language::divide_op>()) {
-      const DataType type_0 = n.children[0]->m_data_type;
-      const DataType type_1 = n.children[1]->m_data_type;
+      const ASTNodeDataType type_0 = n.children[0]->m_data_type;
+      const ASTNodeDataType type_1 = n.children[1]->m_data_type;
 
       n.m_data_type = dataTypePromotion(type_0, type_1);
-      if (n.m_data_type == DataType::undefined_t) {
+      if (n.m_data_type == ASTNodeDataType::undefined_t) {
         std::ostringstream message;
         message << "undefined binary operator\n"
                 << "note: incompatible operand types " << n.children[0]->string() << " (" << dataTypeName(type_0)
@@ -254,7 +256,7 @@ void
 build_node_data_types(ASTNode& n)
 {
   Assert(n.is_root());
-  n.m_data_type = DataType::void_t;
+  n.m_data_type = ASTNodeDataType::void_t;
 
   internal::build_node_data_types(n);
   std::cout << " - build node data types\n";
@@ -265,7 +267,7 @@ namespace internal
 void
 check_node_data_types(const ASTNode& n)
 {
-  if (n.m_data_type == DataType::undefined_t) {
+  if (n.m_data_type == ASTNodeDataType::undefined_t) {
     throw parse_error("unexpected error: undefined datatype for AST node for " + n.name(), n.begin());
   }
 
@@ -295,7 +297,7 @@ build_node_values(ASTNode& n, std::shared_ptr<SymbolTable>& symbol_table)
         build_node_values(*child, bloc_symbol_table);
       }
     }
-    n.m_data_type = DataType::void_t;
+    n.m_data_type = ASTNodeDataType::void_t;
   } else {
     for (auto& child : n.children) {
       build_node_values(*child, symbol_table);
@@ -332,7 +334,7 @@ void
 build_node_values(ASTNode& n)
 {
   Assert(n.is_root());
-  n.m_data_type                = DataType::void_t;
+  n.m_data_type                = ASTNodeDataType::void_t;
   std::shared_ptr symbol_table = std::make_shared<SymbolTable>();
   internal::build_node_values(n, symbol_table);
   std::cout << " - build node data types\n";
@@ -436,7 +438,7 @@ parser(const std::string& filename)
 
     language::build_node_type(*root_node);
 
-    std::cout << language::ASTPrinter{*root_node} << '\n';
+    std::cout << ASTPrinter{*root_node} << '\n';
 
     ExecUntilBreakOrContinue exec_all;
     root_node->execute(exec_all);
diff --git a/src/language/SymbolTable.hpp b/src/language/SymbolTable.hpp
index 3cfd66a5b392a852ca752de777a99a09d3bf46dd..e86bd1e45c5eaedce0cba80a6581bd4f25688b0a 100644
--- a/src/language/SymbolTable.hpp
+++ b/src/language/SymbolTable.hpp
@@ -9,12 +9,9 @@ class SymbolTable
   class Attributes
   {
    private:
-    using DataType    = language::DataType;
-    using DataVariant = language::DataVariant;
-
     bool m_is_initialized{false};
-    DataType m_data_type{DataType::undefined_t};
-    DataVariant m_value;
+    ASTNodeDataType m_data_type{ASTNodeDataType::undefined_t};
+    ASTNodeDataVariant m_value;
 
    public:
     auto&
@@ -41,14 +38,14 @@ class SymbolTable
       m_is_initialized = true;
     }
 
-    const DataType&
+    const ASTNodeDataType&
     dataType() const
     {
       return m_data_type;
     }
 
     void
-    setDataType(const DataType& data_type)
+    setDataType(const ASTNodeDataType& data_type)
     {
       m_data_type = data_type;
     }
diff --git a/tests/test_ASTBuilder.cpp b/tests/test_ASTBuilder.cpp
index 1aef598c1180da9593046c77873e9d512976af07..40bb550f33a2a0ea2242a9725cba303f75634cae 100644
--- a/tests/test_ASTBuilder.cpp
+++ b/tests/test_ASTBuilder.cpp
@@ -8,7 +8,6 @@
   {                                                                                            \
     static_assert(std::is_same_v<std::decay_t<decltype(data)>, std::string_view>);             \
     static_assert(std::is_same_v<std::decay_t<decltype(expected_output)>, std::string_view>);  \
-    using namespace language;                                                                  \
                                                                                                \
     string_input input{data, "test.pgs"};                                                      \
     auto ast = ASTBuilder::build(input);                                                       \
@@ -591,7 +590,6 @@ clog << "log " << l << "\n";
 1+; // syntax error
 )";
 
-      using namespace language;
       string_input input{data, "test.pgs"};
 
       REQUIRE_THROWS_AS(ASTBuilder::build(input), parse_error);