[FIR] Get rid of JavaSymbolProvider.getJavaTopLevelClasses

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt

@@ -146,16 +146,14 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
             val symbolProvider = session.firSymbolProvider as FirCompositeSymbolProvider
             val javaProvider = symbolProvider.providers.filterIsInstance<JavaSymbolProvider>().first()
 
+            val topLevelJavaClasses = topPsiClasses.map { it.classId(FqName.ROOT) }
+
             fun processClassWithChildren(psiClass: PsiClass, parentFqName: FqName) {
-                val psiFile = psiClass.containingFile
+                val classId = psiClass.classId(parentFqName)
-                val packageStatement = psiFile.children.filterIsInstance<PsiPackageStatement>().firstOrNull()
-                val packageName = packageStatement?.packageName
-                val fqName = parentFqName.child(Name.identifier(psiClass.name!!))
-                val classId = ClassId(packageName?.let { FqName(it) } ?: FqName.ROOT, fqName, false)
                 javaProvider.getClassLikeSymbolByFqName(classId)
                     ?: throw AssertionError(classId.asString())
                 psiClass.innerClasses.forEach {
-                    processClassWithChildren(psiClass = it, parentFqName = fqName)
+                    processClassWithChildren(psiClass = it, parentFqName = classId.relativeClassName)
                 }
             }
             for (psiClass in topPsiClasses) {
@@ -163,7 +161,8 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
             }
 
             val processedJavaClasses = mutableSetOf<FirJavaClass>()
-            for (javaClass in javaProvider.getJavaTopLevelClasses().sortedBy { it.name }) {
+            for (javaClassId in topLevelJavaClasses.sortedBy { it.shortClassName }) {
+                val javaClass = javaProvider.getClassLikeSymbolByFqName(javaClassId)?.fir ?: continue
                 if (javaClass !is FirJavaClass || javaClass in processedJavaClasses) continue
                 renderJavaClass(renderer, javaClass, session)
                 processedJavaClasses += javaClass
@@ -174,6 +173,14 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
         KotlinTestUtils.assertEqualsToFile(expectedFile, javaFirDump)
     }
 
+    private fun PsiClass.classId(parentFqName: FqName): ClassId {
+        val psiFile = this.containingFile
+        val packageStatement = psiFile.children.filterIsInstance<PsiPackageStatement>().firstOrNull()
+        val packageName = packageStatement?.packageName
+        val fqName = parentFqName.child(Name.identifier(this.name!!))
+        return ClassId(packageName?.let { FqName(it) } ?: FqName.ROOT, fqName, false)
+    }
+
     companion object {
         private const val FOREIGN_ANNOTATIONS_SOURCES_PATH = "third-party/annotations"
     }

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

@@ -413,14 +413,6 @@ class JavaSymbolProvider(
         }
     }
 
-    @TestOnly
-    fun getJavaTopLevelClasses(): List<FirRegularClass> {
-        return classCache.values
-            .filterIsInstance<FirRegularClassSymbol>()
-            .filter { it.classId.relativeClassName.parent().isRoot }
-            .map { it.fir }
-    }
-
     private val knownClassNamesInPackage = mutableMapOf<FqName, Set<String>?>()
 
     private fun hasTopLevelClassOf(classId: ClassId): Boolean {

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/AbstractFirMultiModuleResolveTest.kt

@@ -19,11 +19,8 @@ import org.jetbrains.kotlin.fir.extensions.BunchOfRegisteredExtensions
 import org.jetbrains.kotlin.fir.extensions.extensionService
 import org.jetbrains.kotlin.fir.extensions.registerExtensions
 import org.jetbrains.kotlin.fir.java.*
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.firProvider
-import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
 import org.jetbrains.kotlin.fir.resolve.transformers.createAllTransformerBasedResolveProcessors
@@ -140,22 +137,27 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
             KotlinTestUtils.assertEqualsToFile(File(expectedPath), firFileDump)
         }
 
-        val processedJavaClasses = mutableSetOf<FirJavaClass>()
+        /*
-        val javaFirDump = StringBuilder().also { builder ->
+         * This code is commented due to deleted JavaSymbolProvider.getJavaTopLevelClasses() method
-            val renderer = FirRenderer(builder)
+         * There is no replace for this code because of there are no tests for this test runner, so
-            for (session in sessions) {
+         *   it is questionable, do we need java class check (or that test runner at all)
-                val symbolProvider = session.firSymbolProvider as FirCompositeSymbolProvider
+         */
-                val javaProvider = symbolProvider.providers.filterIsInstance<JavaSymbolProvider>().first()
+//        val processedJavaClasses = mutableSetOf<FirJavaClass>()
-                for (javaClass in javaProvider.getJavaTopLevelClasses().sortedBy { it.name }) {
+//        val javaFirDump = StringBuilder().also { builder ->
-                    if (javaClass !is FirJavaClass || javaClass in processedJavaClasses) continue
+//            val renderer = FirRenderer(builder)
-                    renderJavaClass(renderer, javaClass, session)
+//            for (session in sessions) {
-                    processedJavaClasses += javaClass
+//                val symbolProvider = session.firSymbolProvider as FirCompositeSymbolProvider
-                }
+//                val javaProvider = symbolProvider.providers.filterIsInstance<JavaSymbolProvider>().first()
-            }
+//                for (javaClass in javaProvider.getJavaTopLevelClasses().sortedBy { it.name }) {
-        }.toString()
+//                    if (javaClass !is FirJavaClass || javaClass in processedJavaClasses) continue
-        if (javaFirDump.isNotEmpty()) {
+//                    renderJavaClass(renderer, javaClass, session)
-            KotlinTestUtils.assertEqualsToFile(File("$dirPath/extraDump.java.txt"), javaFirDump)
+//                    processedJavaClasses += javaClass
-        }
+//                }
+//            }
+//        }.toString()
+//        if (javaFirDump.isNotEmpty()) {
+//            KotlinTestUtils.assertEqualsToFile(File("$dirPath/extraDump.java.txt"), javaFirDump)
+//        }
     }
 }