Add missing tests for ASTNodeBuiltinFunctionExpressionBuilder

Also remove the treatment of tuple of function arguments, since this
kind of argument cannot be defined in the language (by now?).

src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp

@@ -231,9 +231,6 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
       }
       case ASTNodeDataType::double_t: {
         return std::make_unique<FunctionTupleArgumentConverter<ParameterContentT, double>>(argument_number);
-      }
-      case ASTNodeDataType::function_t: {
-        return std::make_unique<FunctionTupleArgumentConverter<ParameterContentT, FunctionSymbolId>>(argument_number);
       }
         // LCOV_EXCL_START
       default: {
@@ -513,11 +510,13 @@ ASTNodeBuiltinFunctionExpressionBuilder::_buildArgumentProcessors(
   const size_t parameters_number = parameter_type_list.size();
 
   if (arguments_number != parameters_number) {
+    // LCOV_EXCL_START
     std::ostringstream error_message;
     error_message << "bad number of arguments: expecting " << rang::fgB::yellow << parameters_number
                   << rang::style::reset << rang::style::bold << ", provided " << rang::fgB::yellow << arguments_number
                   << rang::style::reset;
-    throw ParseError(error_message.str(), argument_nodes.begin());
+    throw UnexpectedError(error_message.str());
+    // LCOV_EXCL_STOP
   }
 
   for (size_t i = 0; i < arguments_number; ++i) {

tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp

@@ -1664,6 +1664,42 @@ fidToR(f);
 
       CHECK_AST(data, result);
     }
+
+    SECTION("tuple(FunctionSymbolId) -> R")
+    {
+      std::string_view data = R"(
+let f : R^3 -> R, x -> 0;
+fidTupleToR((f,f));
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::function_evaluation:BuiltinFunctionProcessor)
+     +-(language::name:fidTupleToR:FakeProcessor)
+     `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+         +-(language::name:f:NameProcessor)
+         `-(language::name:f:NameProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
+
+    SECTION("tuple(FunctionSymbolId) -> R  [with single value tuple]")
+    {
+      std::string_view data = R"(
+let f : R^3 -> R, x -> 0;
+fidTupleToR(f);
+)";
+
+      std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::function_evaluation:BuiltinFunctionProcessor)
+     +-(language::name:fidTupleToR:FakeProcessor)
+     `-(language::name:f:NameProcessor)
+)";
+
+      CHECK_AST(data, result);
+    }
   }
 
   SECTION("errors")

tests/test_BuiltinFunctionRegister.hpp

@@ -100,6 +100,11 @@ class test_BuiltinFunctionRegister
       std::make_pair("fidToR:function", std::make_shared<BuiltinFunctionEmbedder<double(const FunctionSymbolId&)>>(
                                           [](const FunctionSymbolId&) -> double { return 0; })));
 
+    m_name_builtin_function_map.insert(
+      std::make_pair("fidTupleToR:(function...)",
+                     std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<FunctionSymbolId>)>>(
+                       [](const std::vector<FunctionSymbolId>&) -> double { return 0; })));
+
     m_name_builtin_function_map.insert(
       std::make_pair("builtinToBuiltin:builtin_t",
                      std::make_shared<