diff --git a/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp b/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
index 6c1db0335b2f46a8410baed7f02e59efa6ae49c8..6a91a15d13978b423daa563c1b668c5fe0f93489 100644
--- a/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
@@ -523,9 +523,11 @@ ASTNodeFunctionExpressionBuilder::ASTNodeFunctionExpressionBuilder(ASTNode& node
       case ASTNodeDataType::type_id_t: {
         return ASTNodeDataType::build<ASTNodeDataType::type_id_t>(image_domain_node.m_data_type.nameOfTypeId());
       }
+        // LCOV_EXCL_START
       default: {
         throw UnexpectedError("invalid function return type");
       }
+        // LCOV_EXCL_STOP
       }
     }();
 
@@ -546,9 +548,11 @@ ASTNodeFunctionExpressionBuilder::ASTNodeFunctionExpressionBuilder(ASTNode& node
     case ASTNodeDataType::type_id_t: {
       return ASTNodeDataType::build<ASTNodeDataType::type_id_t>(function_image_domain.m_data_type.nameOfTypeId());
     }
+      // LCOV_EXCL_START
     default: {
       throw UnexpectedError("invalid function return type");
     }
+      // LCOV_EXCL_STOP
     }
   }();
 
diff --git a/tests/test_ASTNodeFunctionExpressionBuilder.cpp b/tests/test_ASTNodeFunctionExpressionBuilder.cpp
index d10d243a8de7b16b3b6c33bc81d55343b2298953..b37dd10869bb5665c9292b22e363af09be4b9ead 100644
--- a/tests/test_ASTNodeFunctionExpressionBuilder.cpp
+++ b/tests/test_ASTNodeFunctionExpressionBuilder.cpp
@@ -9,34 +9,54 @@
 #include <language/ast/ASTNodeFunctionExpressionBuilder.hpp>
 #include <language/ast/ASTNodeTypeCleaner.hpp>
 #include <language/ast/ASTSymbolTableBuilder.hpp>
+#include <language/utils/ASTNodeDataTypeTraits.hpp>
 #include <language/utils/ASTPrinter.hpp>
+#include <language/utils/BasicAffectationRegistrerFor.hpp>
+#include <language/utils/TypeDescriptor.hpp>
 #include <utils/Demangle.hpp>
 
 #include <pegtl/string_input.hpp>
 
-#define CHECK_AST(data, expected_output)                                                            \
-  {                                                                                                 \
-    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>) or    \
-                  (std::is_same_v<std::decay_t<decltype(expected_output)>, std::string>));          \
-                                                                                                    \
-    TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};                                      \
-    auto ast = ASTBuilder::build(input);                                                            \
-                                                                                                    \
-    ASTModulesImporter{*ast};                                                                       \
-    ASTNodeTypeCleaner<language::import_instruction>{*ast};                                         \
-                                                                                                    \
-    ASTSymbolTableBuilder{*ast};                                                                    \
-    ASTNodeDataTypeBuilder{*ast};                                                                   \
-                                                                                                    \
-    ASTNodeTypeCleaner<language::var_declaration>{*ast};                                            \
-    ASTNodeTypeCleaner<language::fct_declaration>{*ast};                                            \
-    ASTNodeExpressionBuilder{*ast};                                                                 \
-                                                                                                    \
-    std::stringstream ast_output;                                                                   \
-    ast_output << '\n' << ASTPrinter{*ast, ASTPrinter::Format::raw, {ASTPrinter::Info::exec_type}}; \
-                                                                                                    \
-    REQUIRE(ast_output.str() == expected_output);                                                   \
+template <>
+inline ASTNodeDataType ast_node_data_type_from<std::shared_ptr<const double>> =
+  ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t");
+const auto builtin_data_type = ast_node_data_type_from<std::shared_ptr<const double>>;
+
+#define CHECK_AST(data, expected_output)                                                                        \
+  {                                                                                                             \
+    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>) or                \
+                  (std::is_same_v<std::decay_t<decltype(expected_output)>, std::string>));                      \
+                                                                                                                \
+    TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};                                                  \
+    auto ast = ASTBuilder::build(input);                                                                        \
+                                                                                                                \
+    ASTModulesImporter{*ast};                                                                                   \
+    BasicAffectationRegisterFor<EmbeddedData>{ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t")}; \
+                                                                                                                \
+    ASTNodeTypeCleaner<language::import_instruction>{*ast};                                                     \
+    SymbolTable& symbol_table = *ast->m_symbol_table;                                                           \
+    auto [i_symbol, success]  = symbol_table.add(builtin_data_type.nameOfTypeId(), ast->begin());               \
+    if (not success) {                                                                                          \
+      throw UnexpectedError("cannot add '" + builtin_data_type.nameOfTypeId() + "' type for testing");          \
+    }                                                                                                           \
+                                                                                                                \
+    i_symbol->attributes().setDataType(ASTNodeDataType::build<ASTNodeDataType::type_name_id_t>());              \
+    i_symbol->attributes().setIsInitialized();                                                                  \
+    i_symbol->attributes().value() = symbol_table.typeEmbedderTable().size();                                   \
+    symbol_table.typeEmbedderTable().add(std::make_shared<TypeDescriptor>(builtin_data_type.nameOfTypeId()));   \
+                                                                                                                \
+    ASTSymbolTableBuilder{*ast};                                                                                \
+    ASTNodeDataTypeBuilder{*ast};                                                                               \
+                                                                                                                \
+    ASTNodeTypeCleaner<language::var_declaration>{*ast};                                                        \
+    ASTNodeTypeCleaner<language::fct_declaration>{*ast};                                                        \
+    ASTNodeExpressionBuilder{*ast};                                                                             \
+                                                                                                                \
+    std::stringstream ast_output;                                                                               \
+    ast_output << '\n' << ASTPrinter{*ast, ASTPrinter::Format::raw, {ASTPrinter::Info::exec_type}};             \
+                                                                                                                \
+    REQUIRE(ast_output.str() == expected_output);                                                               \
   }
 
 #define CHECK_AST_THROWS(data)                                                     \
@@ -938,6 +958,27 @@ f(2,(1,2,3),(2,3,-1,1.3));
     }
   }
 
+  SECTION("return a builtin_t")
+  {
+    SECTION("builtin_t argument")
+    {
+      std::string_view data = R"(
+let foo : builtin_t -> builtin_t, b -> b;
+let b0 : builtin_t;
+foo(b0);
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::function_evaluation:FunctionProcessor)
+     +-(language::name:foo:NameProcessor)
+     `-(language::name:b0:NameProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+  }
+
   SECTION("errors")
   {
     SECTION("wrong argument number")