Clean-up function and C-function management

Also allow treatment of function dealing with string type

src/language/ASTNodeCFunctionExpressionBuilder.cpp

@@ -6,48 +6,47 @@
 #include <node_processor/CFunctionProcessor.hpp>
 
 PUGS_INLINE std::unique_ptr<INodeProcessor>
-ASTNodeCFunctionExpressionBuilder::_getArgumentProcessor(ASTNode& argument_node,
-                                                         const ASTNodeDataType& argument_type,
+ASTNodeCFunctionExpressionBuilder::_getArgumentProcessor(const ASTNodeDataType& parameter_type,
+                                                         ASTNode& argument_node,
                                                          ASTNodeDataVariant& argument_value)
 {
-  auto get_function_argument_processor_for_parameter_type =
-    [&](const auto& argument_v) -> std::unique_ptr<INodeProcessor> {
-    using ArgumentT = std::decay_t<decltype(argument_v)>;
-    switch (argument_type) {
+  auto get_function_argument_processor_for = [&](const auto& parameter_v) -> std::unique_ptr<INodeProcessor> {
+    using ParameterT = std::decay_t<decltype(parameter_v)>;
+    switch (argument_node.m_data_type) {
     case ASTNodeDataType::bool_t: {
-      return std::make_unique<CFunctionArgumentProcessor<ArgumentT, bool>>(argument_node, argument_value);
+      return std::make_unique<CFunctionArgumentProcessor<ParameterT, bool>>(argument_node, argument_value);
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return std::make_unique<CFunctionArgumentProcessor<ArgumentT, uint64_t>>(argument_node, argument_value);
+      return std::make_unique<CFunctionArgumentProcessor<ParameterT, uint64_t>>(argument_node, argument_value);
     }
     case ASTNodeDataType::int_t: {
-      return std::make_unique<CFunctionArgumentProcessor<ArgumentT, int64_t>>(argument_node, argument_value);
+      return std::make_unique<CFunctionArgumentProcessor<ParameterT, int64_t>>(argument_node, argument_value);
     }
     case ASTNodeDataType::double_t: {
-      return std::make_unique<CFunctionArgumentProcessor<ArgumentT, double>>(argument_node, argument_value);
+      return std::make_unique<CFunctionArgumentProcessor<ParameterT, double>>(argument_node, argument_value);
     }
     default: {
-      throw parse_error("unexpected error: undefined parameter type for function", std::vector{argument_node.begin()});
+      throw parse_error("invalid argument type for function", std::vector{argument_node.begin()});
     }
     }
   };
 
   auto get_function_argument_processor_for_argument_type = [&]() {
-    switch (argument_node.m_data_type) {
+    switch (parameter_type) {
     case ASTNodeDataType::bool_t: {
-      return get_function_argument_processor_for_parameter_type(bool{});
+      return get_function_argument_processor_for(bool{});
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return get_function_argument_processor_for_parameter_type(uint64_t{});
+      return get_function_argument_processor_for(uint64_t{});
     }
     case ASTNodeDataType::int_t: {
-      return get_function_argument_processor_for_parameter_type(int64_t{});
+      return get_function_argument_processor_for(int64_t{});
     }
     case ASTNodeDataType::double_t: {
-      return get_function_argument_processor_for_parameter_type(double{});
+      return get_function_argument_processor_for(double{});
     }
     default: {
-      throw parse_error("invalid argument type for function", std::vector{argument_node.begin()});
+      throw parse_error("unexpected error: undefined parameter type for function", std::vector{argument_node.begin()});
     }
     }
   };
@@ -57,21 +56,21 @@ ASTNodeCFunctionExpressionBuilder::_getArgumentProcessor(ASTNode& argument_node,
 
 PUGS_INLINE
 void
-ASTNodeCFunctionExpressionBuilder::_storeArgumentProcessor(const size_t argument_number,
+ASTNodeCFunctionExpressionBuilder::_storeArgumentProcessor(const std::vector<ASTNodeDataType>& parameter_type_list,
+                                                           const size_t argument_number,
                                                            ASTNode& argument_node,
-                                                           const std::vector<ASTNodeDataType>& argument_type_list,
                                                            CFunctionProcessor& c_function_processor)
 {
   auto& argument_values = c_function_processor.argumentValues();
 
   c_function_processor.addArgumentProcessor(
-    this->_getArgumentProcessor(argument_node, argument_type_list[argument_number], argument_values[argument_number]));
+    this->_getArgumentProcessor(parameter_type_list[argument_number], argument_node, argument_values[argument_number]));
 }
 
 PUGS_INLINE
 void
-ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(ASTNode& node,
-                                                            const std::vector<ASTNodeDataType>& argument_type_list,
+ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(const std::vector<ASTNodeDataType>& parameter_type_list,
+                                                            ASTNode& node,
                                                             CFunctionProcessor& c_function_processor)
 {
   ASTNode& argument_nodes = *node.children[1];
@@ -81,7 +80,7 @@ ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(ASTNode& node,
 
   c_function_processor.setNumberOfArguments(arguments_number);
 
-  const size_t parameters_number = argument_type_list.size();
+  const size_t parameters_number = parameter_type_list.size();
 
   if (arguments_number != parameters_number) {
     std::ostringstream error_message;
@@ -93,10 +92,10 @@ ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(ASTNode& node,
   if (arguments_number > 1) {
     for (size_t i = 0; i < arguments_number; ++i) {
       ASTNode& argument_node = *argument_nodes.children[i];
-      this->_storeArgumentProcessor(i, argument_node, argument_type_list, c_function_processor);
+      this->_storeArgumentProcessor(parameter_type_list, i, argument_node, c_function_processor);
     }
   } else {
-    this->_storeArgumentProcessor(0, argument_nodes, argument_type_list, c_function_processor);
+    this->_storeArgumentProcessor(parameter_type_list, 0, argument_nodes, c_function_processor);
   }
 }
 
@@ -111,11 +110,11 @@ ASTNodeCFunctionExpressionBuilder::ASTNodeCFunctionExpressionBuilder(ASTNode& no
   CFunctionEmbedderTable& c_function_embedder_table = node.m_symbol_table->cFunctionEbedderTable();
   std::shared_ptr c_function_embedder               = c_function_embedder_table[c_function_id];
 
-  std::vector<ASTNodeDataType> c_function_argument_type_list = c_function_embedder->getArgumentDataTypes();
+  std::vector<ASTNodeDataType> c_function_parameter_type_list = c_function_embedder->getParameterDataTypes();
 
   std::unique_ptr c_function_processor = std::make_unique<CFunctionProcessor>();
 
-  this->_buildArgumentProcessors(node, c_function_argument_type_list, *c_function_processor);
+  this->_buildArgumentProcessors(c_function_parameter_type_list, node, *c_function_processor);
 
   c_function_processor->setFunctionExpressionProcessor(
     std::make_unique<CFunctionExpressionProcessor>(node, c_function_embedder, c_function_processor->argumentValues()));

src/language/ASTNodeCFunctionExpressionBuilder.hpp

@@ -9,19 +9,19 @@ class CFunctionProcessor;
 class ASTNodeCFunctionExpressionBuilder
 {
  private:
-  PUGS_INLINE std::unique_ptr<INodeProcessor> _getArgumentProcessor(ASTNode& argument_node,
-                                                                    const ASTNodeDataType& argument_type,
+  PUGS_INLINE std::unique_ptr<INodeProcessor> _getArgumentProcessor(const ASTNodeDataType& parameter_type,
+                                                                    ASTNode& argument_node,
                                                                     ASTNodeDataVariant& argument_value);
 
   PUGS_INLINE
-  void _storeArgumentProcessor(const size_t argument_number,
+  void _storeArgumentProcessor(const std::vector<ASTNodeDataType>& parameter_type_list,
+                               const size_t argument_number,
                                ASTNode& argument_node,
-                               const std::vector<ASTNodeDataType>& argument_type_list,
                                CFunctionProcessor& c_function_processor);
 
   PUGS_INLINE
-  void _buildArgumentProcessors(ASTNode& node,
-                                const std::vector<ASTNodeDataType>& argument_type_list,
+  void _buildArgumentProcessors(const std::vector<ASTNodeDataType>& parameter_type_list,
+                                ASTNode& node,
                                 CFunctionProcessor& c_function_processor);
 
  public:

src/language/ASTNodeDataTypeBuilder.cpp

@@ -110,6 +110,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n)
             data_type = ASTNodeDataType::unsigned_int_t;
           } else if (type_node.is_type<language::R_set>()) {
             data_type = ASTNodeDataType::double_t;
+          } else if (type_node.is_type<language::string_type>()) {
+            data_type = ASTNodeDataType::string_t;
           }
 
           if (data_type == ASTNodeDataType::undefined_t) {
@@ -158,6 +160,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n)
             value_type = ASTNodeDataType::unsigned_int_t;
           } else if (image_node.is_type<language::R_set>()) {
             value_type = ASTNodeDataType::double_t;
+          } else if (image_node.is_type<language::string_type>()) {
+            value_type = ASTNodeDataType::string_t;
           }
 
           if (value_type == ASTNodeDataType::undefined_t) {
@@ -282,6 +286,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n)
             data_type = ASTNodeDataType::unsigned_int_t;
           } else if (image_domain_node.is_type<language::R_set>()) {
             data_type = ASTNodeDataType::double_t;
+          } else if (image_domain_node.is_type<language::string_type>()) {
+            data_type = ASTNodeDataType::string_t;
           }
         }
 

src/language/ASTNodeFunctionExpressionBuilder.cpp

@@ -8,23 +8,22 @@
 
 template <typename SymbolType>
 PUGS_INLINE std::unique_ptr<INodeProcessor>
-ASTNodeFunctionExpressionBuilder::_getArgumentProcessor(ASTNode& argument_node, SymbolType& parameter_symbol)
+ASTNodeFunctionExpressionBuilder::_getArgumentProcessor(SymbolType& parameter_symbol, ASTNode& argument_node)
 {
-  auto get_function_argument_processor_for_parameter_type =
-    [&](const auto& argument_v) -> std::unique_ptr<INodeProcessor> {
-    using ArgumentT = std::decay_t<decltype(argument_v)>;
-    switch (parameter_symbol.attributes().dataType()) {
+  auto get_function_argument_processor_for = [&](const auto& parameter_v) -> std::unique_ptr<INodeProcessor> {
+    using ParameterT = std::decay_t<decltype(parameter_v)>;
+    switch (argument_node.m_data_type) {
     case ASTNodeDataType::bool_t: {
-      return std::make_unique<FunctionArgumentProcessor<ArgumentT, bool>>(argument_node, parameter_symbol);
+      return std::make_unique<FunctionArgumentProcessor<ParameterT, bool>>(parameter_symbol, argument_node);
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return std::make_unique<FunctionArgumentProcessor<ArgumentT, uint64_t>>(argument_node, parameter_symbol);
+      return std::make_unique<FunctionArgumentProcessor<ParameterT, uint64_t>>(parameter_symbol, argument_node);
     }
     case ASTNodeDataType::int_t: {
-      return std::make_unique<FunctionArgumentProcessor<ArgumentT, int64_t>>(argument_node, parameter_symbol);
+      return std::make_unique<FunctionArgumentProcessor<ParameterT, int64_t>>(parameter_symbol, argument_node);
     }
     case ASTNodeDataType::double_t: {
-      return std::make_unique<FunctionArgumentProcessor<ArgumentT, double>>(argument_node, parameter_symbol);
+      return std::make_unique<FunctionArgumentProcessor<ParameterT, double>>(parameter_symbol, argument_node);
     }
       // LCOV_EXCL_START
     default: {
@@ -34,29 +33,58 @@ ASTNodeFunctionExpressionBuilder::_getArgumentProcessor(ASTNode& argument_node,
     }
   };
 
-  auto get_function_argument_processor_for_argument_type = [&]() {
+  auto get_function_argument_processor_for_string = [&]() -> std::unique_ptr<INodeProcessor> {
     switch (argument_node.m_data_type) {
     case ASTNodeDataType::bool_t: {
-      return get_function_argument_processor_for_parameter_type(bool{});
+      return std::make_unique<FunctionArgumentProcessor<std::string, bool>>(parameter_symbol, argument_node);
     }
     case ASTNodeDataType::unsigned_int_t: {
-      return get_function_argument_processor_for_parameter_type(uint64_t{});
+      return std::make_unique<FunctionArgumentProcessor<std::string, uint64_t>>(parameter_symbol, argument_node);
     }
     case ASTNodeDataType::int_t: {
-      return get_function_argument_processor_for_parameter_type(int64_t{});
+      return std::make_unique<FunctionArgumentProcessor<std::string, int64_t>>(parameter_symbol, argument_node);
     }
     case ASTNodeDataType::double_t: {
-      return get_function_argument_processor_for_parameter_type(double{});
+      return std::make_unique<FunctionArgumentProcessor<std::string, double>>(parameter_symbol, argument_node);
+    }
+    case ASTNodeDataType::string_t: {
+      return std::make_unique<FunctionArgumentProcessor<std::string, std::string>>(parameter_symbol, argument_node);
     }
       // LCOV_EXCL_START
     default: {
-      throw parse_error("unexpected error: undefined argument type for function", std::vector{argument_node.begin()});
+      throw parse_error("unexpected error: undefined parameter type for function", std::vector{argument_node.begin()});
     }
       // LCOV_EXCL_STOP
     }
   };
 
-  return get_function_argument_processor_for_argument_type();
+  auto get_function_argument_processor_for_parameter_type = [&]() {
+    switch (parameter_symbol.attributes().dataType()) {
+    case ASTNodeDataType::bool_t: {
+      return get_function_argument_processor_for(bool{});
+    }
+    case ASTNodeDataType::unsigned_int_t: {
+      return get_function_argument_processor_for(uint64_t{});
+    }
+    case ASTNodeDataType::int_t: {
+      return get_function_argument_processor_for(int64_t{});
+    }
+    case ASTNodeDataType::double_t: {
+      return get_function_argument_processor_for(double{});
+    }
+    case ASTNodeDataType::string_t: {
+      return get_function_argument_processor_for_string();
+    }
+
+      // LCOV_EXCL_START
+    default: {
+      throw parse_error("unexpected error: undefined parameter type for function", std::vector{argument_node.begin()});
+    }
+      // LCOV_EXCL_STOP
+    }
+  };
+
+  return get_function_argument_processor_for_parameter_type();
 }
 
 PUGS_INLINE
@@ -71,7 +99,7 @@ ASTNodeFunctionExpressionBuilder::_storeArgumentProcessor(ASTNode& parameter_var
     parameter_variable.m_symbol_table->find(parameter_variable.string(), parameter_variable.begin());
   Assert(found);
 
-  function_processor.addArgumentProcessor(this->_getArgumentProcessor(argument_node, *i_parameter_symbol));
+  function_processor.addArgumentProcessor(this->_getArgumentProcessor(*i_parameter_symbol, argument_node));
 }
 
 PUGS_INLINE
@@ -128,6 +156,13 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType ex
     }
     case ASTNodeDataType::double_t: {
       return std::make_unique<FunctionExpressionProcessor<ReturnT, double>>(node);
+    }
+    case ASTNodeDataType::string_t: {
+      if constexpr (std::is_same_v<ReturnT, std::string>) {
+        return std::make_unique<FunctionExpressionProcessor<ReturnT, std::string>>(node);
+      } else {
+        throw parse_error("invalid string conversion", std::vector{node.children[1]->begin()});
+      }
     }
       // LCOV_EXCL_START
     default: {
@@ -151,6 +186,9 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType ex
     }
     case ASTNodeDataType::double_t: {
       return get_function_processor_for_expression_value(double{});
+    }
+    case ASTNodeDataType::string_t: {
+      return get_function_processor_for_expression_value(std::string{});
     }
       // LCOV_EXCL_START
     default: {

src/language/ASTNodeFunctionExpressionBuilder.hpp

@@ -11,8 +11,8 @@ class ASTNodeFunctionExpressionBuilder
 {
  private:
   template <typename SymbolType>
-  PUGS_INLINE std::unique_ptr<INodeProcessor> _getArgumentProcessor(ASTNode& argument_node,
-                                                                    SymbolType& parameter_symbol);
+  PUGS_INLINE std::unique_ptr<INodeProcessor> _getArgumentProcessor(SymbolType& parameter_symbol,
+                                                                    ASTNode& argument_node);
 
   PUGS_INLINE
   void _storeArgumentProcessor(ASTNode& parameter_variable,

src/language/CFunctionEmbedder.hpp

@@ -18,11 +18,11 @@
 class ICFunctionEmbedder
 {
  public:
-  virtual size_t numberOfArguments() const = 0;
+  virtual size_t numberOfParameters() const = 0;
 
   virtual ASTNodeDataType getReturnDataType() const = 0;
 
-  virtual std::vector<ASTNodeDataType> getArgumentDataTypes() const = 0;
+  virtual std::vector<ASTNodeDataType> getParameterDataTypes() const = 0;
 
   virtual void apply(const std::vector<ASTNodeDataVariant>& x, ASTNodeDataVariant& f_x) const = 0;
 
@@ -61,18 +61,18 @@ class CFunctionEmbedder : public ICFunctionEmbedder
 
   template <size_t I>
   PUGS_INLINE ASTNodeDataType
-  _getOneArgumentDataType(ArgsTuple& t) const
+  _getOneParameterDataType(ArgsTuple& t) const
   {
     return ast_node_data_type_from_pod<std::decay_t<decltype(std::get<I>(t))>>;
   }
 
   template <size_t... I>
   PUGS_INLINE std::vector<ASTNodeDataType>
-  _getArgumentDataTypes(ArgsTuple t, std::index_sequence<I...>) const
+  _getParameterDataTypes(ArgsTuple t, std::index_sequence<I...>) const
   {
-    std::vector<ASTNodeDataType> argument_type_list;
-    (argument_type_list.push_back(this->_getOneArgumentDataType<I>(t)), ...);
-    return argument_type_list;
+    std::vector<ASTNodeDataType> parameter_type_list;
+    (parameter_type_list.push_back(this->_getOneParameterDataType<I>(t)), ...);
+    return parameter_type_list;
   }
 
  public:
@@ -83,17 +83,17 @@ class CFunctionEmbedder : public ICFunctionEmbedder
   }
 
   PUGS_INLINE std::vector<ASTNodeDataType>
-  getArgumentDataTypes() const final
+  getParameterDataTypes() const final
   {
     constexpr size_t N = std::tuple_size_v<ArgsTuple>;
     ArgsTuple t;
     using IndexSequence = std::make_index_sequence<N>;
 
-    return this->_getArgumentDataTypes(t, IndexSequence{});
+    return this->_getParameterDataTypes(t, IndexSequence{});
   }
 
   PUGS_INLINE size_t
-  numberOfArguments() const final
+  numberOfParameters() const final
   {
     return sizeof...(Args);
   }

src/language/node_processor/CFunctionProcessor.hpp

@@ -7,7 +7,7 @@
 
 #include <CFunctionEmbedder.hpp>
 
-template <typename ProvidedValueType, typename ExpectedValueType>
+template <typename ExpectedValueType, typename ProvidedValueType>
 class CFunctionArgumentProcessor final : public INodeProcessor
 {
  private:

src/language/node_processor/FunctionProcessor.hpp

@@ -8,12 +8,12 @@
 
 #include <node_processor/INodeProcessor.hpp>
 
-template <typename ProvidedValueType, typename ExpectedValueType>
+template <typename ExpectedValueType, typename ProvidedValueType>
 class FunctionArgumentProcessor final : public INodeProcessor
 {
  private:
-  ASTNode& m_provided_value_node;
   ASTNodeDataVariant& m_symbol_value;
+  ASTNode& m_provided_value_node;
 
  public:
   void
@@ -23,13 +23,15 @@ class FunctionArgumentProcessor final : public INodeProcessor
 
     if constexpr (std::is_same_v<ExpectedValueType, ProvidedValueType>) {
       m_symbol_value = m_provided_value_node.m_value;
+    } else if constexpr (std::is_same_v<ExpectedValueType, std::string>) {
+      m_symbol_value = std::to_string(std::get<ProvidedValueType>(m_provided_value_node.m_value));
     } else {
       m_symbol_value = static_cast<ExpectedValueType>(std::get<ProvidedValueType>(m_provided_value_node.m_value));
     }
   }
 
-  FunctionArgumentProcessor(ASTNode& provided_value_node, SymbolTable::Symbol& argument_symbol)
-    : m_provided_value_node{provided_value_node}, m_symbol_value{argument_symbol.attributes().value()}
+  FunctionArgumentProcessor(SymbolTable::Symbol& argument_symbol, ASTNode& provided_value_node)
+    : m_symbol_value{argument_symbol.attributes().value()}, m_provided_value_node{provided_value_node}
   {}
 };
 
@@ -48,6 +50,8 @@ class FunctionExpressionProcessor final : public INodeProcessor
 
     if constexpr (std::is_same_v<ReturnType, ExpressionValueType>) {
       m_node.m_value = m_function_expression.m_value;
+    } else if constexpr (std::is_same_v<ReturnType, std::string>) {
+      m_node.m_value = std::to_string(std::get<ExpressionValueType>(m_function_expression.m_value));
     } else {
       m_node.m_value = static_cast<ReturnType>(std::get<ExpressionValueType>(m_function_expression.m_value));
     }

tests/test_ASTNodeDataTypeBuilder.cpp

@@ -280,54 +280,6 @@ let f : R -> B, (x,y) -> 3;
 
         REQUIRE_THROWS_AS(ASTNodeDataTypeBuilder{*ast}, parse_error);
       }
-
-      SECTION("invalid parameter type")
-      {
-        std::string_view data = R"(
-let f : string -> N, s -> 3;
-)";
-        string_input input{data, "test.pgs"};
-        auto ast = ASTBuilder::build(input);
-        ASTSymbolTableBuilder{*ast};
-
-        REQUIRE_THROWS_AS(ASTNodeDataTypeBuilder{*ast}, parse_error);
-      }
-
-      SECTION("invalid parameter type 2")
-      {
-        std::string_view data = R"(
-let f : N*string -> N, (i,s) -> i;
-)";
-        string_input input{data, "test.pgs"};
-        auto ast = ASTBuilder::build(input);
-        ASTSymbolTableBuilder{*ast};
-
-        REQUIRE_THROWS_AS(ASTNodeDataTypeBuilder{*ast}, parse_error);
-      }
-
-      SECTION("invalid return type")
-      {
-        std::string_view data = R"(
-let f : R -> string, x -> "foo";
-)";
-        string_input input{data, "test.pgs"};
-        auto ast = ASTBuilder::build(input);
-        ASTSymbolTableBuilder{*ast};
-
-        REQUIRE_THROWS_AS(ASTNodeDataTypeBuilder{*ast}, parse_error);
-      }
-
-      SECTION("invalid return type 2")
-      {
-        std::string_view data = R"(
-let f : R -> N*string, x -> (2,"foo");
-)";
-        string_input input{data, "test.pgs"};
-        auto ast = ASTBuilder::build(input);
-        ASTSymbolTableBuilder{*ast};
-
-        REQUIRE_THROWS_AS(ASTNodeDataTypeBuilder{*ast}, parse_error);
-      }
     }
   }
 

tests/test_CFunctionEmbedder.cpp

@@ -19,10 +19,10 @@ TEST_CASE("CFunctionEmbedder", "[language]")
     embedded_sin.apply({arg_variant}, result);
 
     REQUIRE(std::get<double>(result) == std::sin(arg));
-    REQUIRE(embedded_sin.numberOfArguments() == 1);
+    REQUIRE(embedded_sin.numberOfParameters() == 1);
 
     REQUIRE(embedded_sin.getReturnDataType() == ASTNodeDataType::double_t);
-    REQUIRE(embedded_sin.getArgumentDataTypes()[0] == ASTNodeDataType::double_t);
+    REQUIRE(embedded_sin.getParameterDataTypes()[0] == ASTNodeDataType::double_t);
   }
 
   SECTION("multiple variant args")
@@ -43,11 +43,11 @@ TEST_CASE("CFunctionEmbedder", "[language]")
     embedded_c.apply(args, result);
 
     REQUIRE(std::get<bool>(result) == c(d_arg, i_arg));
-    REQUIRE(embedded_c.numberOfArguments() == 2);
+    REQUIRE(embedded_c.numberOfParameters() == 2);
 
     REQUIRE(embedded_c.getReturnDataType() == ASTNodeDataType::bool_t);
-    REQUIRE(embedded_c.getArgumentDataTypes()[0] == ASTNodeDataType::double_t);
-    REQUIRE(embedded_c.getArgumentDataTypes()[1] == ASTNodeDataType::unsigned_int_t);
+    REQUIRE(embedded_c.getParameterDataTypes()[0] == ASTNodeDataType::double_t);
+    REQUIRE(embedded_c.getParameterDataTypes()[1] == ASTNodeDataType::unsigned_int_t);
   }
 
   SECTION("ICFunctionEmbedder")
@@ -68,11 +68,11 @@ TEST_CASE("CFunctionEmbedder", "[language]")
     i_embedded_c->apply(args, result);
 
     REQUIRE(std::get<bool>(result) == c(d_arg, i_arg));
-    REQUIRE(i_embedded_c->numberOfArguments() == 2);
+    REQUIRE(i_embedded_c->numberOfParameters() == 2);
 
     REQUIRE(i_embedded_c->getReturnDataType() == ASTNodeDataType::bool_t);
-    REQUIRE(i_embedded_c->getArgumentDataTypes()[0] == ASTNodeDataType::double_t);
-    REQUIRE(i_embedded_c->getArgumentDataTypes()[1] == ASTNodeDataType::unsigned_int_t);
+    REQUIRE(i_embedded_c->getParameterDataTypes()[0] == ASTNodeDataType::double_t);
+    REQUIRE(i_embedded_c->getParameterDataTypes()[1] == ASTNodeDataType::unsigned_int_t);
   }
 
   SECTION("error")