Kotlin extractor: scope Object-method redeclaration recovery

Why this is needed:
- library-tests/java-kotlin-collection-type-generic-methods/test.ql regressed with extra equals(Object) rows on generic collection/map/list declaration variants.
- At the same time, java-interface-redeclares-tostring must still recover Object-method redeclarations for Java binary interfaces under K2.

What changed:
- In K2 ASM probing, treat classes with kotlin.Metadata as non-Java binaries for javaBinaryDeclaresMethod, so Java-redeclaration recovery does not fire on Kotlin binary classes.
- Keep equals(Object) K2 Any/Any? compatibility handling, but constrain the workaround to non-generic parent classes and skip it when a concrete sibling declaration already exists.
- Preserve the existing toString/hashCode redeclaration recovery path for affected Java binaries.

Effect:
- Removes the spurious equals(Object) rows in java-kotlin-collection-type-generic-methods while retaining expected Object-method extraction in java-interface-redeclares-tostring.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: andersfugmann

java/kotlin-extractor/src/main/kotlin/KotlinFileExtractor.kt

@@ -180,11 +180,20 @@ open class KotlinFileExtractor(
             return try {
                 val bytes = virtualFile.contentsToByteArray()
                 var found = false
+                var hasKotlinMetadata = false
                 val reader = org.jetbrains.org.objectweb.asm.ClassReader(bytes)
                 reader.accept(
                     object : org.jetbrains.org.objectweb.asm.ClassVisitor(
                         org.jetbrains.org.objectweb.asm.Opcodes.ASM9
                     ) {
+                        override fun visitAnnotation(
+                            descriptor: String,
+                            visible: Boolean
+                        ): org.jetbrains.org.objectweb.asm.AnnotationVisitor? {
+                            if (descriptor == "Lkotlin/Metadata;") hasKotlinMetadata = true
+                            return null
+                        }
+
                         override fun visitMethod(
                             access: Int,
                             methodName: String,
@@ -200,7 +209,7 @@ open class KotlinFileExtractor(
                         org.jetbrains.org.objectweb.asm.ClassReader.SKIP_DEBUG or
                         org.jetbrains.org.objectweb.asm.ClassReader.SKIP_FRAMES
                 )
-                found
+                if (hasKotlinMetadata) false else found
             } catch (e: Exception) {
                 logger.warn("Failed to check binary class methods for ${c.fqNameWhenAvailable}: $e")
                 null
@@ -212,21 +221,51 @@ open class KotlinFileExtractor(
     private fun isJavaBinaryDeclaration(f: IrFunction) =
         f.parentClassOrNull?.let { javaBinaryDeclaresMethod(it, f.name.asString()) } ?: false
 
+    private fun hasConcreteSiblingObjectMethod(f: IrFunction): Boolean {
+        val parentClass = f.parentClassOrNull ?: return false
+        return parentClass.declarations
+            .asSequence()
+            .filterIsInstance<IrFunction>()
+            .filter { sibling ->
+                sibling !== f &&
+                    sibling.name == f.name &&
+                    sibling.codeQlValueParameters.size == f.codeQlValueParameters.size
+            }
+            .any { sibling ->
+                val hasInvisibleFakeVisibility =
+                    sibling.visibility.let {
+                        it is DelegatedDescriptorVisibility && it.delegate == Visibilities.InvisibleFake
+                    }
+                !sibling.isFakeOverride && !hasInvisibleFakeVisibility
+            }
+    }
+
     private fun isJavaBinaryObjectMethodRedeclaration(d: IrDeclaration) =
         when (d) {
             is IrFunction ->
-                when (d.name.asString()) {
-                    "toString" -> d.codeQlValueParameters.isEmpty()
-                    "hashCode" -> d.codeQlValueParameters.isEmpty()
-                    // Under K2 (language version 2.0+), the Object.equals(Object) parameter is
-                    // typed as Any (non-nullable) rather than Any? (nullable). Accept both.
-                    "equals" ->
-                        d.codeQlValueParameters
-                            .singleOrNull()
-                            ?.type
-                            ?.let { it.isNullableAny() || it.isAny() } ?: false
-                    else -> false
-                } && isJavaBinaryDeclaration(d)
+                d.parentClassOrNull?.let { parentClass ->
+                    // K2 specific: Only suppress Object-method redeclarations when using K2
+                    // (VirtualFileBasedSourceElement source). K1 uses JavaSourceElement and
+                    // always emits these methods from Java interop signatures (e.g. equals(Object)
+                    // on Map/Collection implementations). Suppressing them under K1 causes
+                    // missing row entries in Kotlin1 parity tests.
+                    parentClass.source is VirtualFileBasedSourceElement &&
+                        parentClass.typeParameters.isEmpty() &&
+                        when (d.name.asString()) {
+                            "toString" -> d.codeQlValueParameters.isEmpty()
+                            "hashCode" -> d.codeQlValueParameters.isEmpty()
+                            // Under K2 (language version 2.0+), the Object.equals(Object) parameter
+                            // is typed as Any (non-nullable) rather than Any? (nullable). Accept both.
+                            "equals" ->
+                                d.codeQlValueParameters
+                                    .singleOrNull()
+                                    ?.type
+                                    ?.let { it.isNullableAny() || it.isAny() } ?: false
+                            else -> false
+                        } &&
+                        !hasConcreteSiblingObjectMethod(d) &&
+                        isJavaBinaryDeclaration(d)
+                } ?: false
             else -> false
         }