Fix no targets for invocation for abstract this type

Author: CaelmBleidd

utbot-framework-test/src/test/kotlin/org/utbot/examples/objects/AbstractAnonymousClassTest.kt

@@ -0,0 +1,15 @@
+package org.utbot.examples.objects
+
+import org.junit.jupiter.api.Test
+import org.utbot.testcheckers.eq
+import org.utbot.testing.UtValueTestCaseChecker
+
+class AbstractAnonymousClassTest : UtValueTestCaseChecker(testClass = AbstractAnonymousClass::class) {
+    @Test
+    fun testNonOverriddenMethod() {
+        check(
+            AbstractAnonymousClass::methodWithoutOverrides,
+            eq(1)
+        )
+    }
+}

utbot-framework/src/main/kotlin/org/utbot/engine/Traverser.kt

@@ -1365,7 +1365,40 @@ class Traverser(
                 possibleConcreteTypes
             )
         } else {
-            typeStoragePossiblyWithOverriddenTypes
+            if (addr.isThisAddr) {
+                val possibleTypes = typeStoragePossiblyWithOverriddenTypes.possibleConcreteTypes
+                val isTypeInappropriate = type.sootClass?.isInappropriate == true
+
+                // If we're trying to construct this instance and it has an inappropriate type,
+                // we won't be able to instantiate its instance in resulting tests.
+                // Therefore, we have to test one of its inheritors that does not override
+                // the method under test
+                if (isTypeInappropriate) {
+                    val possibleTypesWithNonOverriddenMethod = possibleTypes
+                        .filterTo(mutableSetOf()) {
+                            val methods = (it as RefType).sootClass.methods
+                            methods.none { method ->
+                                val methodUnderTest = environment.method
+                                val parameterTypes = method.parameterTypes
+
+                                method.name == methodUnderTest.name && parameterTypes == methodUnderTest.parameterTypes
+                            }
+                        }
+
+                    require(possibleTypesWithNonOverriddenMethod.isNotEmpty()) {
+                        "We do not support testing for abstract classes (or interfaces) without any non-abstract " +
+                                "inheritors (implementors). Probably, it'll be supported in the future."
+                    }
+
+                    TypeStorage.constructTypeStorageUnsafe(type, possibleTypesWithNonOverriddenMethod)
+                } else {
+                    // If we create a `this` instance and its type is instantiatable,
+                    // we should construct a type storage with single type
+                    TypeStorage.constructTypeStorageWithSingleType(type)
+                }
+            } else {
+                typeStoragePossiblyWithOverriddenTypes
+            }
         }
 
         val typeHardConstraint = typeRegistry.typeConstraint(addr, typeStorage).all().asHardConstraint()
@@ -2238,7 +2271,7 @@ class Traverser(
                 if (type.sootClass.isEnum) {
                     createEnum(type, addr)
                 } else {
-                    createObject(addr, type, useConcreteType = addr.isThisAddr, mockInfoGenerator)
+                    createObject(addr, type, useConcreteType = false, mockInfoGenerator)
                 }
             }
             is VoidType -> voidValue

utbot-sample/src/main/java/org/utbot/examples/objects/AbstractAnonymousClass.java

@@ -4,6 +4,14 @@ abstract class AbstractAnonymousClass {
     abstract int constValue();
     abstract int add(int x);
 
+    public int methodWithoutOverrides(int x, int y) {
+        return y + addFortyTwo(x);
+    }
+
+    public int addFortyTwo(int x) {
+        return x + 42;
+    }
+
     public static AbstractAnonymousClass getInstance(int x) {
         if (x % 2 == 0) {
             return new AnonymousClassAlternative();