Rename ASTNodeDataType::typeName to ASTNodeDataType::nameOfTypeId

It purposely diminish the ambiguity with the dataTypeName() function.

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()});
       }
     };
 

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 {

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;

src/language/modules/BuiltinModule.cpp

@@ -18,8 +18,10 @@ BuiltinModule::_addBuiltinFunction(const std::string& name,
 }
 
 void
-BuiltinModule::_addTypeDescriptor(std::shared_ptr<TypeDescriptor> type_descriptor)
+BuiltinModule::_addTypeDescriptor(const ASTNodeDataType& ast_node_data_type)
 {
+  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");

src/language/modules/BuiltinModule.hpp

 #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&

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>>(

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<

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 << attributes.m_value;
+        os << "function_id";
+      } else {
+        os << dataTypeName(attributes.dataType());
+      }
+      os << rang::style::reset << ':' << attributes.m_value;
 
       return os;
     }

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());

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