FIR: Minor. Rename JavaClassConverter -> FirJavaFacade

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

@@ -46,7 +46,7 @@ import org.jetbrains.kotlin.types.Variance.INVARIANT
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
 @ThreadSafeMutableState
-class JavaClassConverter(
+class FirJavaFacade(
     private val session: FirSession,
     private val baseModuleData: FirModuleData,
     private val classFinder: JavaClassFinder

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

@@ -24,28 +24,28 @@ import org.jetbrains.kotlin.name.Name
 // in order to load Kotlin classes as well.
 class JavaSymbolProvider(
     session: FirSession,
-    private val javaClassConverter: JavaClassConverter,
+    private val javaFacade: FirJavaFacade,
 ) : FirSymbolProvider(session) {
 
     private val classCache =
         session.firCachesFactory.createCacheWithPostCompute(
             createValue = { classId: ClassId, parentClassSymbol: FirRegularClassSymbol? ->
-                javaClassConverter.findClass(classId)?.let { FirRegularClassSymbol(classId) to (it to parentClassSymbol) }
+                javaFacade.findClass(classId)?.let { FirRegularClassSymbol(classId) to (it to parentClassSymbol) }
                     ?: null to (null to null)
             },
             postCompute = { _, classSymbol, (javaClass, parentClassSymbol) ->
                 if (classSymbol != null && javaClass != null) {
-                    javaClassConverter.convertJavaClassToFir(classSymbol, parentClassSymbol, javaClass)
+                    javaFacade.convertJavaClassToFir(classSymbol, parentClassSymbol, javaClass)
                 }
             }
         )
 
     override fun getPackage(fqName: FqName): FqName? =
-        javaClassConverter.getPackage(fqName)
+        javaFacade.getPackage(fqName)
 
     override fun getClassLikeSymbolByClassId(classId: ClassId): FirRegularClassSymbol? =
         try {
-            if (javaClassConverter.hasTopLevelClassOf(classId)) getFirJavaClass(classId) else null
+            if (javaFacade.hasTopLevelClassOf(classId)) getFirJavaClass(classId) else null
         } catch (e: ProcessCanceledException) {
             null
         }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt

@@ -12,11 +12,10 @@ import org.jetbrains.kotlin.fir.ThreadSafeMutableState
 import org.jetbrains.kotlin.fir.declarations.getDeprecationInfos
 import org.jetbrains.kotlin.fir.deserialization.*
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.java.JavaClassConverter
+import org.jetbrains.kotlin.fir.java.FirJavaFacade
 import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
-import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.kotlin.*
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion
@@ -38,14 +37,14 @@ class KotlinDeserializedJvmSymbolsProvider(
     kotlinScopeProvider: FirKotlinScopeProvider,
     private val packagePartProvider: PackagePartProvider,
     private val kotlinClassFinder: KotlinClassFinder,
-    private val javaClassConverter: JavaClassConverter,
+    private val javaFacade: FirJavaFacade,
 ) : AbstractFirDeserializedSymbolsProvider(session, moduleDataProvider, kotlinScopeProvider) {
     private val annotationsLoader = AnnotationsLoader(session, kotlinClassFinder)
 
     override fun computePackagePartsInfos(packageFqName: FqName): List<PackagePartsCacheData> {
         return packagePartProvider.findPackageParts(packageFqName.asString()).mapNotNull { partName ->
             val classId = ClassId.topLevel(JvmClassName.byInternalName(partName).fqNameForTopLevelClassMaybeWithDollars)
-            if (!javaClassConverter.hasTopLevelClassOf(classId)) return@mapNotNull null
+            if (!javaFacade.hasTopLevelClassOf(classId)) return@mapNotNull null
             val (kotlinJvmBinaryClass, byteContent) =
                 kotlinClassFinder.findKotlinClassOrContent(classId) as? KotlinClassFinder.Result.KotlinClass ?: return@mapNotNull null
 
@@ -89,18 +88,18 @@ class KotlinDeserializedJvmSymbolsProvider(
 
     private fun loadJavaClass(classId: ClassId, content: ByteArray?): ClassMetadataFindResult? {
         val javaClass = try {
-            javaClassConverter.findClass(classId, content) ?: return null
+            javaFacade.findClass(classId, content) ?: return null
         } catch (e: ProcessCanceledException) {
             return null
         }
         return ClassMetadataFindResult.NoMetadata { symbol ->
-            javaClassConverter.convertJavaClassToFir(symbol, classId.outerClassId?.let(::getClass), javaClass)
+            javaFacade.convertJavaClassToFir(symbol, classId.outerClassId?.let(::getClass), javaClass)
         }
     }
 
     override fun extractClassMetadata(classId: ClassId, parentContext: FirDeserializationContext?): ClassMetadataFindResult? {
         // Kotlin classes are annotated Java classes, so this check also looks for them.
-        if (!javaClassConverter.hasTopLevelClassOf(classId)) return null
+        if (!javaFacade.hasTopLevelClassOf(classId)) return null
 
         val result = try {
             kotlinClassFinder.findKotlinClassOrContent(classId)
@@ -128,7 +127,7 @@ class KotlinDeserializedJvmSymbolsProvider(
     }
 
     override fun getPackage(fqName: FqName): FqName? =
-        javaClassConverter.getPackage(fqName)
+        javaFacade.getPackage(fqName)
 
     private fun loadAnnotationsFromClassFile(
         kotlinClass: KotlinClassFinder.Result.KotlinClass,