[TS] Prefer class definitions over phantom import declarations; richer diagnostics

Path-alias imports (`@/comparator`) produce phantom classes — a signature
with no method bodies — that shadowed the real same-named class in method
resolution and in input generation. The resolver now ranks same-named
classes by substance (method bodies + fields), falls back from a phantom
exact signature match to a substantial twin, and resolveInstanceMethod
tries substantial twins when the receiver's own chain has no body for the
method; the generator instantiates the most substantial class of a name.

Unsupported diagnostics now print the receiver class signature (for
objects) and the target method signature (for function values), which
localized the next frontier precisely: several corpus files declare
comparator fields with a function type in the IR while the code calls
Comparator *methods* on them (`this.#compareFn.lessThan(a, b)`) — a
ts-frontend field-typing mismatch, recorded as jacodb#361 feedback rather
than papered over by generator heuristics.

Author: CaelmBleidd

usvm-ts-pbt/src/main/kotlin/org/usvm/ts/pbt/gen/Generators.kt

@@ -73,15 +73,11 @@ class InputGenerator(
         is EtsArrayType -> genArray(type.elementType, depth)
 
         is EtsClassType -> genRefByName(type.signature.name, depth)
-            ?: run {
-                val cls = scene.projectAndSdkClasses.firstOrNull { it.signature == type.signature }
-                    ?: scene.projectAndSdkClasses.firstOrNull { it.name == type.signature.name }
-                if (cls != null) instantiate(cls, depth) else VObject(null)
-            }
+            ?: substantialClassByName(type.signature.name)?.let { instantiate(it, depth) }
+            ?: VObject(null)
 
         is EtsUnclearRefType -> genRefByName(type.name, depth)
-            ?: scene.projectAndSdkClasses.firstOrNull { it.name == type.name }
-                ?.let { instantiate(it, depth) }
+            ?: substantialClassByName(type.name)?.let { instantiate(it, depth) }
             ?: VObject(null)
 
         is EtsFunctionType -> genFunction(type)
@@ -183,6 +179,12 @@ class InputGenerator(
         return VArray(MutableList(size) { generate(elementType, depth + 1) })
     }
 
+    /** Prefer definitions over phantom declarations produced by path-alias imports. */
+    private fun substantialClassByName(name: String): EtsClass? =
+        scene.projectAndSdkClasses
+            .filter { it.name == name }
+            .maxByOrNull { c -> c.methods.count { it.cfg.stmts.isNotEmpty() } * 2 + c.fields.size }
+
     private fun instantiate(cls: EtsClass, depth: Int): VObject {
         val fields = mutableMapOf<String, VValue>()
         if (depth < 3) {

usvm-ts-pbt/src/main/kotlin/org/usvm/ts/pbt/interpreter/CallResolver.kt

@@ -21,14 +21,27 @@ import org.jacodb.ets.utils.DEFAULT_ARK_METHOD_NAME
 internal class CallResolver(private val scene: EtsScene) {
 
     private val classesByName: Map<String, List<EtsClass>> by lazy {
-        (scene.projectClasses + scene.sdkClasses).groupBy { it.name }
+        (scene.projectClasses + scene.sdkClasses)
+            .groupBy { it.name }
+            // Prefer definitions over declarations: path-alias imports produce
+            // phantom classes (a signature with no method bodies) that would
+            // otherwise shadow the real class of the same name.
+            .mapValues { (_, classes) -> classes.sortedByDescending { it.substance() } }
     }
 
+    private fun EtsClass.substance(): Int =
+        methods.count { it.cfg.stmts.isNotEmpty() } * 2 + fields.size
+
     fun classByName(name: String): EtsClass? = classesByName[name]?.firstOrNull()
 
     fun classBySignature(signature: EtsClassSignature): EtsClass? {
         val candidates = classesByName[signature.name] ?: return null
-        return candidates.firstOrNull { it.signature == signature } ?: candidates.firstOrNull()
+        val exact = candidates.firstOrNull { it.signature == signature }
+        // A phantom exact match loses to a substantial same-named class.
+        if (exact != null && exact.substance() == 0) {
+            candidates.firstOrNull { it.substance() > 0 }?.let { return it }
+        }
+        return exact ?: candidates.firstOrNull()
     }
 
     /** Resolve an instance method by name on [cls], walking the superclass chain. */
@@ -40,7 +53,13 @@ internal class CallResolver(private val scene: EtsScene) {
                 ?.let { return it }
             current = current.superClass?.let { classBySignature(it) }
         }
-        return null
+        // The receiver's class may be a phantom produced by a path-alias import:
+        // fall back to a substantial same-named class that declares the method.
+        return classesByName[cls.name].orEmpty()
+            .asSequence()
+            .filter { it !== cls }
+            .mapNotNull { twin -> twin.methods.firstOrNull { it.name == name && it.cfg.stmts.isNotEmpty() } }
+            .firstOrNull()
     }
 
     /** Resolve a static call target (including free functions in the default class). */

usvm-ts-pbt/src/main/kotlin/org/usvm/ts/pbt/interpreter/EtsConcreteInterpreter.kt

@@ -584,7 +584,11 @@ class EtsConcreteInterpreter(
 
                     Intrinsics.callInstance(receiver, name, args, ::invokeFunction)
                         ?: throw UnsupportedFeatureSignal(
-                            "instance method: $name on ${receiver::class.simpleName}"
+                            "instance method: $name on " + when (receiver) {
+                                is VObject -> "VObject(${receiver.cls?.signature ?: "<record>"})"
+                                is VFunction -> "VFunction(${receiver.method.signature})"
+                                else -> receiver::class.simpleName
+                            }
                         )
                 }