diff --git a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
index 1295383c4df4b97e784a3862bfb502c95564c0ba..b23169088ed8779f0a51bc3e8144d4277e19de9e 100644
--- a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
@@ -215,7 +215,8 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
           // LCOV_EXCL_STOP
         }
       } else {
-        throw parse_error("invalid operator for '" + data_type.typeName() + "' affectation", std::vector{n.begin()});
+        throw parse_error("invalid operator for '" + data_type.nameOfTypeId() + "' affectation",
+                          std::vector{n.begin()});
       }
     };
 
@@ -240,7 +241,8 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
           // LCOV_EXCL_STOP
         }
       } else {
-        throw parse_error("invalid operator for '" + data_type.typeName() + "' affectation", std::vector{n.begin()});
+        throw parse_error("invalid operator for '" + data_type.nameOfTypeId() + "' affectation",
+                          std::vector{n.begin()});
       }
     };
 
diff --git a/src/language/ast/ASTNodeDataType.cpp b/src/language/ast/ASTNodeDataType.cpp
index 923c751f8c858674123d99458f7322b8c80652b4..38f33ff436679e4d5aaeea976691baa148443195 100644
--- a/src/language/ast/ASTNodeDataType.cpp
+++ b/src/language/ast/ASTNodeDataType.cpp
@@ -57,7 +57,7 @@ dataTypeName(const ASTNodeDataType& data_type)
     name = "type_name_id";
     break;
   case ASTNodeDataType::type_id_t:
-    name = data_type.typeName();
+    name = data_type.nameOfTypeId();
     break;
   case ASTNodeDataType::function_t:
     name = "function";
@@ -96,7 +96,7 @@ isNaturalConversion(const ASTNodeDataType& data_type, const ASTNodeDataType& tar
 {
   if (target_data_type == data_type) {
     if (data_type == ASTNodeDataType::type_id_t) {
-      return (data_type.typeName() == target_data_type.typeName());
+      return (data_type.nameOfTypeId() == target_data_type.nameOfTypeId());
     } else if (data_type == ASTNodeDataType::vector_t) {
       return (data_type.dimension() == target_data_type.dimension());
     } else {
diff --git a/src/language/ast/ASTNodeDataType.hpp b/src/language/ast/ASTNodeDataType.hpp
index 3c65905181878ab0d05887ddd92128003aa5cfcc..863a87dad0a3df9d3659b9c661336fbf5e384aca 100644
--- a/src/language/ast/ASTNodeDataType.hpp
+++ b/src/language/ast/ASTNodeDataType.hpp
@@ -35,15 +35,17 @@ class ASTNodeDataType
   DataType m_data_type;
   std::shared_ptr<ASTNodeDataType> m_content_type;
   size_t m_dimension;
-  std::string m_type_name;
+  std::string m_name_of_type_id;
 
  public:
+  PUGS_INLINE
   size_t
   dimension() const
   {
     return m_dimension;
   }
 
+  PUGS_INLINE
   const ASTNodeDataType&
   contentType() const
   {
@@ -51,12 +53,14 @@ class ASTNodeDataType
     return *m_content_type;
   }
 
+  PUGS_INLINE
   const std::string&
-  typeName() const
+  nameOfTypeId() const
   {
-    return m_type_name;
+    return m_name_of_type_id;
   }
 
+  PUGS_INLINE
   operator const DataType&() const
   {
     return m_data_type;
@@ -66,22 +70,22 @@ class ASTNodeDataType
   ASTNodeDataType& operator=(ASTNodeDataType&&) = default;
 
   ASTNodeDataType(DataType data_type)
-    : m_data_type{data_type}, m_content_type{nullptr}, m_dimension{1}, m_type_name{"unknown"}
+    : m_data_type{data_type}, m_content_type{nullptr}, m_dimension{1}, m_name_of_type_id{"unknown"}
   {}
 
   ASTNodeDataType(DataType data_type, const ASTNodeDataType& content_type)
     : m_data_type{data_type},
       m_content_type{std::make_shared<ASTNodeDataType>(content_type)},
       m_dimension{1},
-      m_type_name{"unknown"}
+      m_name_of_type_id{"unknown"}
   {}
 
   ASTNodeDataType(DataType data_type, size_t dimension)
-    : m_data_type{data_type}, m_content_type{nullptr}, m_dimension{dimension}, m_type_name{"unknown"}
+    : m_data_type{data_type}, m_content_type{nullptr}, m_dimension{dimension}, m_name_of_type_id{"unknown"}
   {}
 
   ASTNodeDataType(DataType data_type, const std::string& type_name)
-    : m_data_type{data_type}, m_content_type{nullptr}, m_dimension{1}, m_type_name{type_name}
+    : m_data_type{data_type}, m_content_type{nullptr}, m_dimension{1}, m_name_of_type_id{type_name}
   {}
 
   ASTNodeDataType(const ASTNodeDataType&) = default;
diff --git a/src/language/modules/BuiltinModule.cpp b/src/language/modules/BuiltinModule.cpp
index 1d1df91fde868610ea4ff51f66aa350aaca0f76d..0ab7911394a9ebb81454c3381a380ea4aca9c03e 100644
--- a/src/language/modules/BuiltinModule.cpp
+++ b/src/language/modules/BuiltinModule.cpp
@@ -18,9 +18,11 @@ BuiltinModule::_addBuiltinFunction(const std::string& name,
 }
 
 void
-BuiltinModule::_addTypeDescriptor(std::shared_ptr<TypeDescriptor> type_descriptor)
+BuiltinModule::_addTypeDescriptor(const ASTNodeDataType& ast_node_data_type)
 {
-  auto [i_type, success] = m_name_type_map.insert(std::make_pair(type_descriptor->name(), type_descriptor));
+  Assert(ast_node_data_type == ASTNodeDataType::type_id_t);
+  std::shared_ptr type_descriptor = std::make_shared<TypeDescriptor>(ast_node_data_type.nameOfTypeId());
+  auto [i_type, success]          = m_name_type_map.insert(std::make_pair(type_descriptor->name(), type_descriptor));
   if (not success) {
     throw NormalError("type '" + type_descriptor->name() + "' cannot be added!\n");
   }
diff --git a/src/language/modules/BuiltinModule.hpp b/src/language/modules/BuiltinModule.hpp
index 58424e868bd22936d877dec6060920affc39759c..bf8743c9e5a9913dd6939e3d6cbe18495bccc27e 100644
--- a/src/language/modules/BuiltinModule.hpp
+++ b/src/language/modules/BuiltinModule.hpp
@@ -1,6 +1,7 @@
 #ifndef BUILTIN_MODULE_HPP
 #define BUILTIN_MODULE_HPP
 
+#include <language/ast/ASTNodeDataType.hpp>
 #include <language/modules/IModule.hpp>
 
 class IBuiltinFunctionEmbedder;
@@ -15,7 +16,7 @@ class BuiltinModule : public IModule
   void _addBuiltinFunction(const std::string& name,
                            std::shared_ptr<IBuiltinFunctionEmbedder> builtin_function_embedder);
 
-  void _addTypeDescriptor(std::shared_ptr<TypeDescriptor> type_descriptor);
+  void _addTypeDescriptor(const ASTNodeDataType& type);
 
  public:
   const NameBuiltinFunctionMap&
diff --git a/src/language/modules/MeshModule.cpp b/src/language/modules/MeshModule.cpp
index 2e434b9d0db6c9af9a59bd78a41cc36a7dcbfda0..f4472b7498d9cff114282fb449064676db669486 100644
--- a/src/language/modules/MeshModule.cpp
+++ b/src/language/modules/MeshModule.cpp
@@ -62,8 +62,7 @@ class MeshTransformation<OutputType(InputType...)> : public PugsFunctionAdapter<
 
 MeshModule::MeshModule()
 {
-  this->_addTypeDescriptor(
-    std::make_shared<TypeDescriptor>(ast_node_data_type_from<std::shared_ptr<const IMesh>>.typeName()));
+  this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IMesh>>);
 
   this->_addBuiltinFunction("readGmsh",
                             std::make_shared<BuiltinFunctionEmbedder<std::shared_ptr<const IMesh>, std::string>>(
diff --git a/src/language/modules/SchemeModule.cpp b/src/language/modules/SchemeModule.cpp
index 176489a7f9d4e9520b1822108b0cee4f8e0ef493..cdfb86ed154e8c4c56227cf041b26b85b0a44e3f 100644
--- a/src/language/modules/SchemeModule.cpp
+++ b/src/language/modules/SchemeModule.cpp
@@ -121,11 +121,8 @@ struct GlaceScheme
 
 SchemeModule::SchemeModule()
 {
-  this->_addTypeDescriptor(
-    std::make_shared<TypeDescriptor>(ast_node_data_type_from<std::shared_ptr<const IBoundaryDescriptor>>.typeName()));
-
-  this->_addTypeDescriptor(std::make_shared<TypeDescriptor>(
-    ast_node_data_type_from<std::shared_ptr<const IBoundaryConditionDescriptor>>.typeName()));
+  this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IBoundaryDescriptor>>);
+  this->_addTypeDescriptor(ast_node_data_type_from<std::shared_ptr<const IBoundaryConditionDescriptor>>);
 
   this->_addBuiltinFunction("boundaryName",
                             std::make_shared<
diff --git a/src/language/utils/SymbolTable.hpp b/src/language/utils/SymbolTable.hpp
index ed4e2549f65dba1eb457aa486eba86a987d6886d..667ae89ae41866cd0da2bd86fbff18be53b9af5f 100644
--- a/src/language/utils/SymbolTable.hpp
+++ b/src/language/utils/SymbolTable.hpp
@@ -86,16 +86,13 @@ class SymbolTable
     friend std::ostream&
     operator<<(std::ostream& os, const Attributes& attributes)
     {
+      os << rang::fg::green;
       if (attributes.m_data_type == ASTNodeDataType::function_t) {
-        os << "function_id:";
-      } else if (attributes.m_data_type == ASTNodeDataType::type_name_id_t) {
-        os << "type_name_id:";
-      } else if (attributes.m_data_type == ASTNodeDataType::type_id_t) {
-        os << attributes.m_data_type.typeName() << ':';
-      } else if (attributes.m_data_type == ASTNodeDataType::tuple_t) {
-        os << attributes.m_data_type.typeName() << ':';
+        os << "function_id";
+      } else {
+        os << dataTypeName(attributes.dataType());
       }
-      os << attributes.m_value;
+      os << rang::style::reset << ':' << attributes.m_value;
 
       return os;
     }
diff --git a/tests/test_ASTSymbolTableBuilder.cpp b/tests/test_ASTSymbolTableBuilder.cpp
index 62df4dce0501a6cb64b3d19e8ae5c1637a4d19fc..0398914c084e4c264bcae9f28f8356ed5885d3dc 100644
--- a/tests/test_ASTSymbolTableBuilder.cpp
+++ b/tests/test_ASTSymbolTableBuilder.cpp
@@ -49,15 +49,15 @@ let f: R*Z*B->R, (x,n,z) -> x+n;
     std::stringstream expected_output;
     expected_output << '\n'
                     << "-- Symbol table state -- parent : " << static_cast<SymbolTable*>(nullptr) << '\n'
-                    << " b: --\n"
-                    << " n: --\n"
-                    << " z: --\n"
-                    << " x: --\n"
-                    << " c0: --\n"
-                    << " c1: --\n"
-                    << " c2: --\n"
-                    << " c3: --\n"
-                    << " f: 0\n"
+                    << " b: undefined:--\n"
+                    << " n: undefined:--\n"
+                    << " z: undefined:--\n"
+                    << " x: undefined:--\n"
+                    << " c0: undefined:--\n"
+                    << " c1: undefined:--\n"
+                    << " c2: undefined:--\n"
+                    << " c3: undefined:--\n"
+                    << " f: undefined:0\n"
                     << "------------------------\n";
 
     REQUIRE(st_output.str() == expected_output.str());
diff --git a/tests/test_SymbolTable.cpp b/tests/test_SymbolTable.cpp
index f7155a4eec5270c30f94323f67c61cad000dbf0b..7eadfc31426ac7cc7154a60d1d0d4c6a4e8649c5 100644
--- a/tests/test_SymbolTable.cpp
+++ b/tests/test_SymbolTable.cpp
@@ -42,7 +42,7 @@ TEST_CASE("SymbolTable", "[language]")
       std::stringstream expected_output;
       expected_output << '\n'
                       << "-- Symbol table state -- parent : " << static_cast<SymbolTable*>(nullptr) << '\n'
-                      << " a: --\n"
+                      << " a: undefined:--\n"
                       << "------------------------\n";
 
       REQUIRE(st_output.str() == expected_output.str());
@@ -60,7 +60,7 @@ TEST_CASE("SymbolTable", "[language]")
       {
         std::stringstream value_output;
         value_output << attributes_a;
-        REQUIRE(value_output.str() == "--");
+        REQUIRE(value_output.str() == "undefined:--");
       }
 
       // defining data
@@ -80,7 +80,7 @@ TEST_CASE("SymbolTable", "[language]")
       {
         std::stringstream value_output;
         value_output << attributes_a;
-        REQUIRE(value_output.str() == "2.3");
+        REQUIRE(value_output.str() == "R:2.3");
       }
 
       SECTION("Output initialized")
@@ -91,7 +91,7 @@ TEST_CASE("SymbolTable", "[language]")
         std::stringstream expected_output;
         expected_output << '\n'
                         << "-- Symbol table state -- parent : " << static_cast<SymbolTable*>(nullptr) << '\n'
-                        << " a: 2.3\n"
+                        << " a: R:2.3\n"
                         << "------------------------\n";
 
         REQUIRE(st_output.str() == expected_output.str());
@@ -159,7 +159,7 @@ TEST_CASE("SymbolTable", "[language]")
     {
       std::stringstream value_output;
       value_output << attributes_a;
-      REQUIRE(value_output.str() == "--");
+      REQUIRE(value_output.str() == "undefined:--");
     }
 
     // defining function data