Check that function's return value is not a non natural conversion

Related to issue #16

src/language/ASTNodeFunctionExpressionBuilder.cpp

@@ -159,6 +159,8 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType ex
                                                         ASTNode& node,
                                                         ASTNode& function_component_expression)
 {
+  ASTNodeNaturalConversionChecker{function_component_expression, expression_value_type, return_value_type};
+
   auto get_function_processor_for_expression_value = [&](const auto& return_v) -> std::unique_ptr<INodeProcessor> {
     using ReturnT = std::decay_t<decltype(return_v)>;
     switch (expression_value_type) {
@@ -178,7 +180,7 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType ex
       if constexpr (std::is_same_v<ReturnT, std::string>) {
         return std::make_unique<FunctionExpressionProcessor<ReturnT, std::string>>(function_component_expression);
       } else {
-        throw parse_error("invalid string conversion", std::vector{node.children[1]->begin()});
+        throw parse_error("unexpected error: invalid string conversion", std::vector{node.children[1]->begin()});
       }
     }
       // LCOV_EXCL_START

tests/test_ASTNodeFunctionExpressionBuilder.cpp

@@ -216,14 +216,14 @@ minus(true);
     SECTION("Z argument")
     {
       std::string_view data = R"(
-let times_2_3 : Z -> Z, z -> z*2.3;
-times_2_3(-2);
+let times_2 : Z -> Z, z -> z*2;
+times_2(-2);
 )";
 
       std::string_view result = R"(
 (root:ASTNodeListProcessor)
  `-(language::function_evaluation:FunctionProcessor)
-     +-(language::name:times_2_3:NameProcessor)
+     +-(language::name:times_2:NameProcessor)
      `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
          `-(language::integer:2:ValueProcessor)
 )";
@@ -354,14 +354,67 @@ sum(2);
       CHECK_AST_THROWS(data);
     }
 
-    SECTION("invalid string conversion")
+    SECTION("invalid return implicit conversion")
+    {
+      SECTION("string -> R")
       {
         std::string_view data = R"(
 let bad_conv : string -> R, s -> s;
 bad_conv(2);
 )";
 
-      CHECK_AST_THROWS_WITH(data, std::string{"invalid string conversion"});
+        CHECK_AST_THROWS_WITH(data, std::string{"invalid implicit conversion: string -> R"});
+      }
+
+      SECTION("R -> B")
+      {
+        std::string_view data = R"(
+let bad_B : R -> B, x -> x;
+bad_B(2);
+)";
+
+        CHECK_AST_THROWS_WITH(data, std::string{"invalid implicit conversion: R -> B"});
+      }
+
+      SECTION("R -> N")
+      {
+        std::string_view data = R"(
+let next : R -> N, x -> x;
+next(6);
+)";
+
+        CHECK_AST_THROWS_WITH(data, std::string{"invalid implicit conversion: R -> N"});
+      }
+
+      SECTION("R -> Z")
+      {
+        std::string_view data = R"(
+let prev : R -> Z, x -> x;
+prev(-3);
+)";
+
+        CHECK_AST_THROWS_WITH(data, std::string{"invalid implicit conversion: R -> Z"});
+      }
+
+      SECTION("N -> B")
+      {
+        std::string_view data = R"(
+let bad_B : N -> B, n -> n;
+bad_B(3);
+)";
+
+        CHECK_AST_THROWS_WITH(data, std::string{"invalid implicit conversion: N -> B"});
+      }
+
+      SECTION("Z -> B")
+      {
+        std::string_view data = R"(
+let bad_B : Z -> B, n -> n;
+bad_B(3);
+)";
+
+        CHECK_AST_THROWS_WITH(data, std::string{"invalid implicit conversion: Z -> B"});
+      }
     }
 
     SECTION("invalid argument implicit conversion")

tests/test_FunctionProcessor.cpp

@@ -219,10 +219,10 @@ Z z = f(-2,4);
       SECTION("from R*Z")
       {
         std::string_view data = R"(
-let f : R*Z -> Z, (p,q) -> p*q;
-Z z = f(-0.5,8);
+let f : R*Z -> R, (p,q) -> p*q;
+R x = f(-0.5,8);
 )";
-        CHECK_FUNCTION_EVALUATION_RESULT(data, "z", -4l);
+        CHECK_FUNCTION_EVALUATION_RESULT(data, "x", double{-0.5 * 8l});
       }
     }