[resolution] KotlinJavaPsiFacade: do not return classes with wrong ClassId

We shouldn't return from `findClass`/`findClasses` Java classes with
`ClassId` different from the requested one

^KT-62892

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirCombinedJavaSymbolProvider.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProviderInternals
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.createJavaClassFinder
-import org.jetbrains.kotlin.load.java.structure.classId
+import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -60,10 +60,7 @@ internal class LLFirCombinedJavaSymbolProvider private constructor(
         classCache.get(classId) { computeClassLikeSymbolByClassId(it) }
 
     private fun computeClassLikeSymbolByClassId(classId: ClassId): FirRegularClassSymbol? {
-        val javaClasses = javaClassFinder.findClasses(classId).filterNot { javaClass ->
+        val javaClasses = javaClassFinder.findClasses(classId).filterNot(JavaClass::hasMetadataAnnotation)
-            javaClass.classId != classId || javaClass.hasMetadataAnnotation()
-        }
-
         if (javaClasses.isEmpty()) return null
 
         val (javaClass, provider) = selectFirstElementInClasspathOrder(javaClasses) { javaClass ->

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaFacade.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -81,8 +81,7 @@ abstract class FirJavaFacade(
     private val statusExtensions = session.extensionService.statusTransformerExtensions
 
     fun findClass(classId: ClassId, knownContent: ByteArray? = null): JavaClass? =
-        classFinder.findClass(JavaClassFinder.Request(classId, knownContent))
+        classFinder.findClass(JavaClassFinder.Request(classId, knownContent))?.takeUnless(JavaClass::hasMetadataAnnotation)
-            ?.takeIf { it.classId == classId && !it.hasMetadataAnnotation() }
 
     fun getPackage(fqName: FqName): FqName? =
         packageCache.getValue(fqName)?.fqName

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/resolve/jvm/KotlinJavaPsiFacade.java

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
- *
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
  */
 
 package org.jetbrains.kotlin.resolve.jvm;
@@ -46,6 +35,7 @@ import org.jetbrains.kotlin.asJava.KtLightClassMarker;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
 import org.jetbrains.kotlin.load.java.JavaClassFinder;
 import org.jetbrains.kotlin.load.java.structure.JavaClass;
+import org.jetbrains.kotlin.load.java.structure.JavaElementsKt;
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl;
 import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementSourceFactory;
 import org.jetbrains.kotlin.name.ClassId;
@@ -164,6 +154,7 @@ public class KotlinJavaPsiFacade implements Disposable {
         return emptyModifierList;
     }
 
+    @Nullable
     public JavaClass findClass(@NotNull JavaClassFinder.Request request, @NotNull GlobalSearchScope scope) {
         if (scope == GlobalSearchScope.EMPTY_SCOPE) return null;
 
@@ -175,9 +166,11 @@ public class KotlinJavaPsiFacade implements Disposable {
 
         if (shouldUseSlowResolve()) {
             PsiClass[] classes = findClassesInDumbMode(qualifiedName, scope);
-            if (classes.length != 0) {
+            for (PsiClass psiClass : classes) {
-                return createJavaClass(classId, classes[0]);
+                JavaClass javaClass = tryCreateJavaClass(classId, psiClass);
+                if (javaClass != null) return javaClass;
             }
+
             return null;
         }
 
@@ -189,7 +182,10 @@ public class KotlinJavaPsiFacade implements Disposable {
             }
             else {
                 PsiClass aClass = finder.findClass(qualifiedName, scope);
-                if (aClass != null) return createJavaClass(classId, aClass);
+                if (aClass == null) continue;
+
+                JavaClass javaClass = tryCreateJavaClass(classId, aClass);
+                if (javaClass != null) return javaClass;
             }
         }
 
@@ -214,15 +210,16 @@ public class KotlinJavaPsiFacade implements Disposable {
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
 
             for (PsiClass psiClass : finder.findClasses(qualifiedName, scope)) {
-                javaClasses.add(createJavaClass(classId, psiClass));
+                JavaClass javaClass = tryCreateJavaClass(classId, psiClass);
+                if (javaClass != null) javaClasses.add(javaClass);
             }
         }
 
         return javaClasses;
     }
 
-    @NotNull
+    @Nullable
-    private JavaClass createJavaClass(@NotNull ClassId classId, @NotNull PsiClass psiClass) {
+    private JavaClass tryCreateJavaClass(@NotNull ClassId classId, @NotNull PsiClass psiClass) {
         JavaClassImpl javaClass = new JavaClassImpl(JavaElementSourceFactory.getInstance(project).createPsiSource(psiClass));
         FqName fqName = classId.asSingleFqName();
         if (!fqName.equals(javaClass.getFqName())) {
@@ -233,6 +230,10 @@ public class KotlinJavaPsiFacade implements Disposable {
             throw new IllegalStateException("Kotlin light classes should not be found by JavaPsiFacade, resolving: " + fqName);
         }
 
+        if (!classId.equals(JavaElementsKt.getClassId(javaClass))) {
+            return null;
+        }
+
         return javaClass;
     }
 

compiler/testData/cli/jvm/javaSrcWrongPackage.out

@@ -1,7 +1,7 @@
-compiler/testData/cli/jvm/javaSrcWrongPackage.kt:1:13: error: unresolved reference 'A'.
+compiler/testData/cli/jvm/javaSrcWrongPackage.kt:1:24: error: return type mismatch: expected 'A.Nested', actual 'foo.A.Nested!'.
-fun test(): A.Nested = A().nested()
-            ^
-compiler/testData/cli/jvm/javaSrcWrongPackage.kt:1:24: error: unresolved reference 'A'.
 fun test(): A.Nested = A().nested()
                        ^
-COMPILATION_ERROR
+compiler/testData/cli/jvm/javaSrcWrongPackage.kt:1:28: error: cannot access class 'foo.A.Nested'. Check your module classpath for missing or conflicting dependencies.
+fun test(): A.Nested = A().nested()
+                           ^
+COMPILATION_ERROR