Introduce object creation using builders for fuzzers

utbot-fuzzing/src/main/kotlin/org/utbot/fuzzing/Api.kt

@@ -141,7 +141,8 @@ sealed interface Seed<TYPE, RESULT> {
     class Recursive<TYPE, RESULT>(
         val construct: Routine.Create<TYPE, RESULT>,
         val modify: Sequence<Routine.Call<TYPE, RESULT>> = emptySequence(),
-        val empty: Routine.Empty<TYPE, RESULT>
+        val empty: Routine.Empty<TYPE, RESULT>,
+        val transformers: Sequence<Routine.Modify<TYPE, RESULT>> = emptySequence(),
     ) : Seed<TYPE, RESULT>
 
     /**
@@ -186,6 +187,13 @@ sealed class Routine<T, R>(val types: List<T>) : Iterable<T> by types {
         }
     }
 
+    class Modify<T, R>(
+        types: List<T>,
+        val callable: (instance: R, arguments: List<R>) -> R
+    ) : Routine<T, R>(types) {
+        operator fun invoke(instance: R, arguments: List<R>): R = callable(instance, arguments)
+    }
+
     /**
      * Creates a collection of concrete sizes.
      */
@@ -541,7 +549,28 @@ private fun <TYPE, RESULT, DESCRIPTION : Description<TYPE>, FEEDBACK : Feedback<
                             parameterIndex = -1
                         }
                     )
+                },
+            transformers = task.transformers.let { transformer ->
+                if (transformer === emptySequence<Node<TYPE, RESULT>>() || transformer.none()) {
+                    emptyList()
+                } else {
+                    transformer.map { f ->
+                        fuzz(
+                            f.types,
+                            fuzzing,
+                            description,
+                            random,
+                            configuration,
+                            f,
+                            state.copy {
+                                recursionTreeDepth++
+                                iterations = -1
+                                parameterIndex = -1
+                            }
+                        )
+                    }.toList()
                 }
+            }
         )
     } catch (nsv: NoSeedValueException) {
         @Suppress("UNCHECKED_CAST")
@@ -577,7 +606,16 @@ private fun <TYPE, R> create(result: Result<TYPE, R>): R = when(result) {
                 else -> error("Undefined object call method ${func.builder}")
             }
         }
-        obj
+        transformers.let { transformers ->
+            var transformed = obj
+            transformers.forEach { transformer ->
+                transformed = when (val builder = transformer.builder) {
+                    is Routine.Modify<TYPE, R> -> builder(obj, transformer.result.map { create(it) })
+                    else -> error("Undefined object call method ${transformer.builder}")
+                }
+            }
+            transformed
+        }
     }
     is Result.Collection<TYPE, R> -> with(result) {
         val collection: R = when (val c = construct.builder) {
@@ -659,6 +697,7 @@ sealed interface Result<TYPE, RESULT> {
     class Recursive<TYPE, RESULT>(
         val construct: Node<TYPE, RESULT>,
         val modify: List<Node<TYPE, RESULT>>,
+        val transformers: List<Node<TYPE, RESULT>>,
     ) : Result<TYPE, RESULT>
 
     /**

utbot-fuzzing/src/main/kotlin/org/utbot/fuzzing/Configuration.kt

@@ -22,7 +22,7 @@ data class Configuration(
      *
      * To stop recursion [Seed.Recursive.empty] is called to create new values.
      */
-    var recursionTreeDepth: Int = 4,
+    var recursionTreeDepth: Int = 5,
 
     /**
      * The limit of collection size to create.

utbot-fuzzing/src/main/kotlin/org/utbot/fuzzing/Mutations.kt

@@ -295,7 +295,8 @@ sealed interface RecursiveMutations<TYPE, RESULT> : Mutation<Pair<Result.Recursi
         ): Result.Recursive<TYPE, RESULT> {
             return Result.Recursive(
                 construct = recursive.mutate(source.construct,random, configuration),
-                modify = source.modify
+                modify = source.modify,
+                transformers = source.transformers,
             )
         }
     }
@@ -309,7 +310,8 @@ sealed interface RecursiveMutations<TYPE, RESULT> : Mutation<Pair<Result.Recursi
         ): Result.Recursive<TYPE, RESULT> {
             return Result.Recursive(
                 construct = source.construct,
-                modify = source.modify.shuffled(random).take(random.nextInt(source.modify.size + 1))
+                modify = source.modify.shuffled(random).take(random.nextInt(source.modify.size + 1)),
+                transformers = source.transformers
             )
         }
     }
@@ -326,7 +328,8 @@ sealed interface RecursiveMutations<TYPE, RESULT> : Mutation<Pair<Result.Recursi
                 modify = source.modify.toMutableList().apply {
                     val i = random.nextInt(0, source.modify.size)
                     set(i, recursive.mutate(source.modify[i], random, configuration))
-                }
+                },
+                transformers = source.transformers
             )
         }
 

utbot-java-fuzzing/src/main/kotlin/org/utbot/fuzzing/JavaLanguage.kt

@@ -42,14 +42,18 @@ fun defaultValueProviders(idGenerator: IdentityPreservingIdGenerator<Int>) = lis
     FloatValueProvider,
     StringValueProvider,
     NumberValueProvider,
-    anyObjectValueProvider(idGenerator),
-    ArrayValueProvider(idGenerator),
-    EnumValueProvider(idGenerator),
-    ListSetValueProvider(idGenerator),
-    MapValueProvider(idGenerator),
-    IteratorValueProvider(idGenerator),
-    EmptyCollectionValueProvider(idGenerator),
-    DateValueProvider(idGenerator),
+    (ObjectValueProvider(idGenerator)
+        with ArrayValueProvider(idGenerator)
+        with EnumValueProvider(idGenerator)
+        with ListSetValueProvider(idGenerator)
+        with MapValueProvider(idGenerator)
+        with IteratorValueProvider(idGenerator)
+        with EmptyCollectionValueProvider(idGenerator)
+        with DateValueProvider(idGenerator))
+            .withFallback(
+                AbstractsObjectValueProvider(idGenerator)
+                        with BuilderObjectValueProvider(idGenerator)
+            ),
     VoidValueProvider,
     NullValueProvider,
 )
@@ -235,6 +239,7 @@ private fun toClassId(type: Type, cache: MutableMap<Type, FuzzedType>): ClassId
         }
         is ParameterizedType -> (type.rawType as Class<*>).id
         is Class<*> -> type.id
+        is TypeVariable<*> -> type.bounds.firstOrNull()?.let { toClassId(it, cache) } ?: objectClassId
         else -> error("unknown type: $type")
     }
 }