Improve exception messages in BExprDb

Author: mikosik

src/virtual-machine/src/main/java/org/smoothbuild/virtualmachine/bytecode/expr/BExprDb.java

@@ -172,29 +172,19 @@ public BFold newFold(BExpr array, BExpr initial, BExpr folder) throws BytecodeEx
 
   private BType validateFoldSubExprsAndGetResultType(BExpr array, BExpr initial, BExpr folder)
       throws BKindDbException {
-    var lambdaType = validateMemberEvaluationTypeClass("folder", folder, BLambdaType.class);
+    var folderType = validateMemberEvaluationTypeClass("folder", folder, BLambdaType.class);
     var arrayType = validateMemberEvaluationTypeClass("array", array, BArrayType.class);
     var initialType = initial.evaluationType();
-    var params = lambdaType.params().elements();
     var elementType = arrayType.element();
-    if (!(params.size() == 2
-        && params.get(0).equals(initialType)
-        && params.get(1).equals(elementType))) {
-      throw illegalEvaluationType(
-          "folder.arguments",
-          expectedFolderArgumentsType(initialType, elementType),
-          lambdaType.params());
-    }
-    var resultType = lambdaType.result();
-    if (!resultType.equals(initialType)) {
-      throw illegalEvaluationType("folder.result", initialType, resultType);
-    }
-    return resultType;
+    var expectedFolderType = folderType(initialType, elementType);
+    validateMemberType("folder", folderType, expectedFolderType);
+    return initialType;
   }
 
-  private BTupleType expectedFolderArgumentsType(BType accumulatorType, BType elementType)
+  private BLambdaType folderType(BType accumulatorType, BType arrayElementType)
       throws BKindDbException {
-    return kindDb.tuple(accumulatorType, elementType);
+    var params = kindDb.tuple(accumulatorType, arrayElementType);
+    return kindDb.lambda(params, accumulatorType);
   }
 
   public BIf newIf(BExpr condition, BExpr then_, BExpr else_) throws BytecodeException {
@@ -207,28 +197,20 @@ public BIf newIf(BExpr condition, BExpr then_, BExpr else_) throws BytecodeExcep
   }
 
   public BMap newMap(BExpr array, BExpr mapper) throws BytecodeException {
-    var mapperArgumentType = validateMapSubExprsAndGetMapperResultType(array, mapper);
-    var kind = kindDb.map(kindDb.array(mapperArgumentType));
+    var mapperResultType = validateMapSubExprsAndGetMapperResultType(array, mapper);
+    var kind = kindDb.map(kindDb.array(mapperResultType));
     var data = writeChain(array.hash(), mapper.hash());
     var root = newRoot(kind, data);
     return kind.newExpr(root, this);
   }
 
   private BType validateMapSubExprsAndGetMapperResultType(BExpr array, BExpr mapper)
       throws BKindDbException {
-    var lambdaType = validateMemberEvaluationTypeClass("mapper", mapper, BLambdaType.class);
+    var mapperType = validateMemberEvaluationTypeClass("mapper", mapper, BLambdaType.class);
     var arrayType = validateMemberEvaluationTypeClass("array", array, BArrayType.class);
-    var params = lambdaType.params().elements();
-    var elementType = arrayType.element();
-    if (!(params.size() == 1 && params.get(0).equals(elementType))) {
-      throw illegalEvaluationType(
-          "mapper.arguments", expectedMapperArgumentsType(elementType), lambdaType.params());
-    }
-    return lambdaType.result();
-  }
-
-  private BTupleType expectedMapperArgumentsType(BType elementType) throws BKindDbException {
-    return kindDb.tuple(elementType);
+    var expectedParamTypes = kindDb.tuple(arrayType.element());
+    validateMemberType("mapper.parameters", mapperType.params(), expectedParamTypes);
+    return mapperType.result();
   }
 
   public BOrder newOrder(BArrayType evaluationType, List<? extends BExpr> elements)
@@ -324,12 +306,14 @@ private void validateOrderElements(BType elementType, List<? extends BExpr> elem
 
   private static <T extends BType> T validateMemberEvaluationTypeClass(
       String memberName, BExpr member, Class<T> clazz) {
-    var lambdaEvaluationType = member.evaluationType();
-    if (!(lambdaEvaluationType.getClass().equals(clazz))) {
-      throw illegalEvaluationType(memberName, clazz, lambdaEvaluationType);
+    var evaluationType = member.evaluationType();
+    var evaluationTypeClass = evaluationType.getClass();
+    if (!(evaluationTypeClass.equals(clazz))) {
+      throw illegalEvaluationType(
+          memberName, clazz.getSimpleName(), evaluationTypeClass.getSimpleName());
     }
     @SuppressWarnings("unchecked")
-    var cast = (T) lambdaEvaluationType;
+    var cast = (T) evaluationType;
     return cast;
   }
 
@@ -341,12 +325,6 @@ private static void validateMemberEvaluationType(
     }
   }
 
-  private static IllegalArgumentException illegalEvaluationType(
-      String name, Class<?> expected, BType actual) {
-    return illegalEvaluationType(
-        name, expected.getSimpleName(), actual.getClass().getSimpleName());
-  }
-
   private static IllegalArgumentException illegalEvaluationType(
       String name, BType expected, BType actual) {
     return illegalEvaluationType(name, expected.name(), actual.name());
@@ -359,7 +337,10 @@ private static IllegalArgumentException illegalEvaluationType(
   }
 
   private static void validateMemberType(String memberName, BValue member, BType expectedType) {
-    var memberType = member.type();
+    validateMemberType(memberName, member.type(), expectedType);
+  }
+
+  private static void validateMemberType(String memberName, BType memberType, BType expectedType) {
     if (!memberType.equals(expectedType)) {
       throw new IllegalArgumentException("`%s.type()` should be `%s` but is `%s`."
           .formatted(memberName, expectedType.name(), memberType.name()));

src/virtual-machine/src/test/java/org/smoothbuild/virtualmachine/bytecode/expr/base/BFoldTest.java

@@ -30,15 +30,15 @@ void creating_fold_with_non_lambda_fails() {
   void creating_fold_with_folder_which_parameter_count_is_different_than_two_fails() {
     assertCall(() -> bytecodeF().fold(bArray(bInt()), bInt(), bLambda(list(bIntType()), bInt())))
         .throwsException(new IllegalArgumentException(
-            "`folder.arguments.evaluationType()` should be `{Int,Int}` but is `{Int}`."));
+            "`folder.type()` should be `(Int,Int)->Int` but is `(Int)->Int`."));
   }
 
   @Test
   void creating_fold_with_folder_that_has_different_first_param_type_than_initial_type_fails() {
     assertCall(() -> bytecodeF()
             .fold(bArray(bInt()), bInt(), bLambda(list(bStringType(), bIntType()), bInt())))
         .throwsException(new IllegalArgumentException(
-            "`folder.arguments.evaluationType()` should be `{Int,Int}` but is `{String,Int}`."));
+            "`folder.type()` should be `(Int,Int)->Int` but is `(String,Int)->Int`."));
   }
 
   @Test
@@ -47,15 +47,15 @@ void creating_fold_with_folder_that_has_different_first_param_type_than_initial_
     assertCall(() -> bytecodeF()
             .fold(bArray(bInt()), bInt(), bLambda(list(bIntType(), bStringType()), bInt())))
         .throwsException(new IllegalArgumentException(
-            "`folder.arguments.evaluationType()` should be `{Int,Int}` but is `{Int,String}`."));
+            "`folder.type()` should be `(Int,Int)->Int` but is `(Int,String)->Int`."));
   }
 
   @Test
   void creating_fold_with_folder_that_has_different_result_type_than_initial_type_fails() {
     assertCall(() -> bytecodeF()
             .fold(bArray(bInt()), bInt(), bLambda(list(bIntType(), bIntType()), bString())))
         .throwsException(new IllegalArgumentException(
-            "`folder.result.evaluationType()` should be `Int` but is `String`."));
+            "`folder.type()` should be `(Int,Int)->Int` but is `(Int,Int)->String`."));
   }
 
   @Nested

src/virtual-machine/src/test/java/org/smoothbuild/virtualmachine/bytecode/expr/base/BMapTest.java

@@ -30,14 +30,14 @@ void creating_map_with_non_lambda_fails() {
   void creating_map_with_mapper_which_parameter_count_is_different_than_one_fails() {
     assertCall(() -> bMap(bArray(bInt()), bii2iLambda()))
         .throwsException(new IllegalArgumentException(
-            "`mapper.arguments.evaluationType()` should be `{Int}` but is `{Int,Int}`."));
+            "`mapper.parameters.type()` should be `{Int}` but is `{Int,Int}`."));
   }
 
   @Test
   void creating_map_with_mapper_that_has_different_type_than_array_element_type_fails() {
     assertCall(() -> bMap(bArray(bString()), bIntIdLambda()))
         .throwsException(new IllegalArgumentException(
-            "`mapper.arguments.evaluationType()` should be `{String}` but is `{Int}`."));
+            "`mapper.parameters.type()` should be `{String}` but is `{Int}`."));
   }
 
   @Nested