[FIR] Drop using of JavaSymbolProvider and OptionalAnnotationClassesProvider in FirCommonSessionFactory

Drop using of all Java stuff inside FirCommonSessionFactory

^KT-56063

compiler/cli/src/org/jetbrains/kotlin/cli/common/FirSessionConstructionUtils.kt

@@ -219,14 +219,12 @@ fun <F> prepareCommonSessions(
         FirCommonSessionFactory.createModuleBasedSession(
             moduleData,
             sessionProvider,
-            librariesScope,
             projectEnvironment,
             incrementalCompilationContext = createProviderAndScopeForIncrementalCompilation(moduleFiles),
             extensionRegistrars,
             configuration.languageVersionSettings,
             lookupTracker = configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER),
             enumWhenTracker = configuration.get(CommonConfigurationKeys.ENUM_WHEN_TRACKER),
-            needRegisterJavaElementFinder = true,
             registerExtraComponents = {},
             init = sessionConfigurator
         )

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/FirJvmAnnotationHelper.kt

@@ -15,11 +15,13 @@ import org.jetbrains.kotlin.name.StandardClassIds
 
 fun <D> FirBasedSymbol<out D>.isCompiledToJvmDefault(
     session: FirSession,
-    jvmDefaultMode: JvmDefaultMode
+    jvmDefaultMode: JvmDefaultMode?
 ): Boolean where D : FirAnnotationContainer, D : FirDeclaration {
     // TODO: Fix support for all cases
     if (getAnnotationByClassId(StandardClassIds.Annotations.JvmDefault, session) != null) return true
 
-    return jvmDefaultMode.forAllMethodsWithBody
+    // jvmDefaultMode is null only on common metadata compilation
+    // TODO: it's unclear what should be returned here if jvmDefaultMode is null, KT-57079
+    return jvmDefaultMode?.forAllMethodsWithBody ?: true
 }
 

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmConflictsChecker.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.java.javaSymbolProvider
 
 object FirJvmConflictsChecker : FirRegularClassChecker() {
     override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
-        val javaSymbol = context.session.javaSymbolProvider.getClassLikeSymbolByClassId(declaration.classId) ?: return
+        val javaSymbol = context.session.javaSymbolProvider?.getClassLikeSymbolByClassId(declaration.classId) ?: return
         reporter.reportOn(
             declaration.source, FirErrors.PACKAGE_OR_CLASSIFIER_REDECLARATION, listOf(declaration.symbol, javaSymbol), context
         )

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmDefaultChecker.kt

@@ -47,7 +47,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
                     reporter.reportOn(source, FirJvmErrors.JVM_DEFAULT_IN_JVM6_TARGET, "JvmDefault", context)
                     return
                 }
-                !jvmDefaultMode.isEnabled -> {
+                jvmDefaultMode?.isEnabled != true -> {
                     reporter.reportOn(source, FirJvmErrors.JVM_DEFAULT_IN_DECLARATION, "JvmDefault", context)
                     return
                 }
@@ -66,7 +66,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
                         )
                         return
                     }
-                    !jvmDefaultMode.isEnabled -> {
+                    jvmDefaultMode?.isEnabled != true -> {
                         reporter.reportOn(
                             source,
                             FirJvmErrors.JVM_DEFAULT_IN_DECLARATION,
@@ -107,12 +107,12 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
 
     private fun checkNonJvmDefaultOverridesJavaDefault(
         defaultAnnotation: FirAnnotation?,
-        jvmDefaultMode: JvmDefaultMode,
+        jvmDefaultMode: JvmDefaultMode?,
         declaration: FirDeclaration,
         context: CheckerContext,
         reporter: DiagnosticReporter
     ) {
-        if (defaultAnnotation != null || jvmDefaultMode.forAllMethodsWithBody) return
+        if (defaultAnnotation != null || jvmDefaultMode?.forAllMethodsWithBody == true) return
         val member = declaration as? FirSimpleFunction ?: return
 
         val containingDeclaration = context.findClosest<FirClassLikeDeclaration>()
@@ -123,7 +123,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
 
             if (overriddenFunctions.any { it.getAnnotationByClassId(JVM_DEFAULT_CLASS_ID, context.session) != null }) {
                 reporter.reportOn(declaration.source, FirJvmErrors.JVM_DEFAULT_REQUIRED_FOR_OVERRIDE, context)
-            } else if (jvmDefaultMode.isEnabled) {
+            } else if (jvmDefaultMode?.isEnabled != false) {
                 for (overriddenFunction in overriddenFunctions) {
                     val overriddenDeclarations = overriddenFunction.getOverriddenDeclarations()
                     for (overriddenDeclaration in overriddenDeclarations) {

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/DefaultCallConflictResolverFactory.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.calls.jvm.ConeEquivalentCallConflictReso
 import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
 import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
 
-object NativeCallConflictResolverFactory : ConeCallConflictResolverFactory() {
+object DefaultCallConflictResolverFactory : ConeCallConflictResolverFactory() {
     override fun create(
         typeSpecificityComparator: TypeSpecificityComparator,
         components: InferenceComponents,

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirCommonSessionFactory.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.SessionConfiguration
 import org.jetbrains.kotlin.fir.checkers.registerJsCheckers
 import org.jetbrains.kotlin.fir.checkers.registerJvmCheckers
 import org.jetbrains.kotlin.fir.checkers.registerNativeCheckers
@@ -18,11 +17,10 @@ import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
 import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
-import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
-import org.jetbrains.kotlin.fir.java.deserialization.OptionalAnnotationClassesProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirBuiltinSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
+import org.jetbrains.kotlin.fir.session.FirSessionFactoryHelper.registerDefaultExtraComponentsForModuleBased
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectEnvironment
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectFileSearchScope
 import org.jetbrains.kotlin.incremental.components.EnumWhenTracker
@@ -48,7 +46,6 @@ object FirCommonSessionFactory : FirAbstractSessionFactory() {
             moduleDataProvider,
             languageVersionSettings,
             registerExtraComponents = {
-                it.registerCommonJavaComponents(projectEnvironment.getJavaModuleResolver())
                 registerExtraComponents(it)
             },
             createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _ -> declaredMemberScope } },
@@ -63,24 +60,20 @@ object FirCommonSessionFactory : FirAbstractSessionFactory() {
                     ),
                     FirBuiltinSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
                     FirCloneableSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
-                    OptionalAnnotationClassesProvider(session, moduleDataProvider, kotlinScopeProvider, packageAndMetadataPartProvider)
                 )
             }
         )
     }
 
-    @OptIn(SessionConfiguration::class)
     fun createModuleBasedSession(
         moduleData: FirModuleData,
         sessionProvider: FirProjectSessionProvider,
-        javaSourcesScope: AbstractProjectFileSearchScope,
         projectEnvironment: AbstractProjectEnvironment,
         incrementalCompilationContext: IncrementalCompilationContext?,
         extensionRegistrars: List<FirExtensionRegistrar>,
         languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
         lookupTracker: LookupTracker? = null,
         enumWhenTracker: EnumWhenTracker? = null,
-        needRegisterJavaElementFinder: Boolean,
         registerExtraComponents: ((FirSession) -> Unit) = {},
         init: FirSessionConfigurator.() -> Unit = {}
     ): FirSession {
@@ -93,8 +86,7 @@ object FirCommonSessionFactory : FirAbstractSessionFactory() {
             enumWhenTracker,
             init,
             registerExtraComponents = {
-                it.registerCommonJavaComponents(projectEnvironment.getJavaModuleResolver())
+                it.registerDefaultExtraComponentsForModuleBased()
-                it.registerJavaSpecificResolveComponents()
                 registerExtraComponents(it)
             },
             registerExtraCheckers = {
@@ -105,7 +97,6 @@ object FirCommonSessionFactory : FirAbstractSessionFactory() {
             createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _ -> declaredMemberScope } },
             createProviders = { session, kotlinScopeProvider, symbolProvider, syntheticFunctionalInterfaceProvider, generatedSymbolsProvider, dependencies ->
                 var symbolProviderForBinariesFromIncrementalCompilation: MetadataSymbolProvider? = null
-                var optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation: OptionalAnnotationClassesProvider? = null
                 incrementalCompilationContext?.let {
                     val precompiledBinariesPackagePartProvider = it.precompiledBinariesPackagePartProvider
                     if (precompiledBinariesPackagePartProvider != null && it.precompiledBinariesFileScope != null) {
@@ -119,36 +110,18 @@ object FirCommonSessionFactory : FirAbstractSessionFactory() {
                                 projectEnvironment.getKotlinClassFinder(it.precompiledBinariesFileScope) as KotlinMetadataFinder,
                                 defaultDeserializationOrigin = FirDeclarationOrigin.Precompiled
                             )
-                        optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation =
-                            OptionalAnnotationClassesProvider(
-                                session,
-                                moduleDataProvider,
-                                kotlinScopeProvider,
-                                precompiledBinariesPackagePartProvider,
-                                defaultDeserializationOrigin = FirDeclarationOrigin.Precompiled
-                            )
                     }
                 }
 
-                val javaSymbolProvider =
-                    JavaSymbolProvider(session, projectEnvironment.getFirJavaFacade(session, moduleData, javaSourcesScope))
-                session.register(JavaSymbolProvider::class, javaSymbolProvider)
-
                 listOfNotNull(
                     symbolProvider,
                     *(incrementalCompilationContext?.previousFirSessionsSymbolProviders?.toTypedArray() ?: emptyArray()),
                     symbolProviderForBinariesFromIncrementalCompilation,
                     generatedSymbolsProvider,
                     syntheticFunctionalInterfaceProvider,
-                    javaSymbolProvider,
                     *dependencies.toTypedArray(),
-                    optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation,
                 )
             }
-        ).also {
+        )
-            if (needRegisterJavaElementFinder) {
-                projectEnvironment.registerAsJavaElementFinder(it)
-            }
-        }
     }
 }

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirNativeSessionFactory.kt

@@ -6,19 +6,18 @@
 package org.jetbrains.kotlin.fir.session
 
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.BinaryModuleData
-import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
+import org.jetbrains.kotlin.fir.FirModuleData
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.checkers.registerNativeCheckers
 import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
-import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirBuiltinSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirExtensionSyntheticFunctionInterfaceProvider
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
-import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
+import org.jetbrains.kotlin.fir.session.FirSessionFactoryHelper.registerDefaultExtraComponentsForModuleBased
-import org.jetbrains.kotlin.fir.scopes.impl.FirEnumEntriesSupport
 import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary
 import org.jetbrains.kotlin.name.Name
 
@@ -73,7 +72,7 @@ object FirNativeSessionFactory : FirAbstractSessionFactory() {
             null,
             init,
             registerExtraComponents = { session ->
-                session.registerExtraComponentsForModuleBased()
+                session.registerDefaultExtraComponentsForModuleBased()
                 registerExtraComponents(session)
             },
             registerExtraCheckers = { it.registerNativeCheckers() },
@@ -88,13 +87,4 @@ object FirNativeSessionFactory : FirAbstractSessionFactory() {
             }
         )
     }
-
-    @OptIn(SessionConfiguration::class)
-    fun FirSession.registerExtraComponentsForModuleBased() {
-        register(FirVisibilityChecker::class, FirVisibilityChecker.Default)
-        register(ConeCallConflictResolverFactory::class, NativeCallConflictResolverFactory)
-        register(FirPlatformClassMapper::class, FirPlatformClassMapper.Default)
-        register(FirOverridesBackwardCompatibilityHelper::class, FirOverridesBackwardCompatibilityHelper.Default())
-        register(FirEnumEntriesSupport::class, FirEnumEntriesSupport(this))
-    }
 }

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirSessionFactoryHelper.kt

@@ -8,8 +8,12 @@ package org.jetbrains.kotlin.fir.session
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
+import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
+import org.jetbrains.kotlin.fir.scopes.impl.FirEnumEntriesSupport
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectEnvironment
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectFileSearchScope
 import org.jetbrains.kotlin.incremental.components.EnumWhenTracker
@@ -116,4 +120,13 @@ object FirSessionFactoryHelper {
             ))
         }
     }
+
+    @OptIn(SessionConfiguration::class)
+    fun FirSession.registerDefaultExtraComponentsForModuleBased() {
+        register(FirVisibilityChecker::class, FirVisibilityChecker.Default)
+        register(ConeCallConflictResolverFactory::class, DefaultCallConflictResolverFactory)
+        register(FirPlatformClassMapper::class, FirPlatformClassMapper.Default)
+        register(FirOverridesBackwardCompatibilityHelper::class, FirOverridesBackwardCompatibilityHelper.Default())
+        register(FirEnumEntriesSupport::class, FirEnumEntriesSupport(this))
+    }
 }

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/MetadataSymbolProvider.kt

@@ -7,6 +7,9 @@ package org.jetbrains.kotlin.fir.session
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.ThreadSafeMutableState
+import org.jetbrains.kotlin.fir.caches.createCache
+import org.jetbrains.kotlin.fir.caches.firCachesFactory
+import org.jetbrains.kotlin.fir.caches.getValue
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.deserialization.*
 import org.jetbrains.kotlin.fir.java.deserialization.KotlinBuiltins
@@ -20,6 +23,7 @@ import org.jetbrains.kotlin.serialization.deserialization.KotlinMetadataFinder
 import org.jetbrains.kotlin.serialization.deserialization.MetadataClassDataFinder
 import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerializerProtocol
 import org.jetbrains.kotlin.serialization.deserialization.readProto
+import org.jetbrains.kotlin.utils.addToStdlib.runIf
 
 @ThreadSafeMutableState
 class MetadataSymbolProvider(
@@ -38,6 +42,8 @@ class MetadataSymbolProvider(
 
     private val constDeserializer = FirConstDeserializer(session, BuiltInSerializerProtocol)
 
+    private val metadataTopLevelClassesInPackageCache = session.firCachesFactory.createCache(::findMetadataTopLevelClassesInPackage)
+
     override fun computePackagePartsInfos(packageFqName: FqName): List<PackagePartsCacheData> {
         return packageAndMetadataPartProvider.findMetadataPackageParts(packageFqName.asString()).mapNotNull { partName ->
             if (partName in KotlinBuiltins) return@mapNotNull null
@@ -62,7 +68,7 @@ class MetadataSymbolProvider(
 
     override fun computePackageSetWithNonClassDeclarations() = packageAndMetadataPartProvider.computePackageSetWithNonClassDeclarations()
 
-    override fun knownTopLevelClassesInPackage(packageFqName: FqName) = kotlinClassFinder.findMetadataTopLevelClassesInPackage(packageFqName)
+    override fun knownTopLevelClassesInPackage(packageFqName: FqName) = metadataTopLevelClassesInPackageCache.getValue(packageFqName)
 
     override fun extractClassMetadata(classId: ClassId, parentContext: FirDeserializationContext?): ClassMetadataFindResult? {
         val classData = classDataFinder.findClassData(classId) ?: return null
@@ -78,5 +84,9 @@ class MetadataSymbolProvider(
 
     override fun isNewPlaceForBodyGeneration(classProto: ProtoBuf.Class) = false
 
-    override fun getPackage(fqName: FqName) = null
+    override fun getPackage(fqName: FqName) =
+        runIf(metadataTopLevelClassesInPackageCache.getValue(fqName)?.isNotEmpty() == true) { fqName }
+
+    private fun findMetadataTopLevelClassesInPackage(packageFqName: FqName) =
+        kotlinClassFinder.findMetadataTopLevelClassesInPackage(packageFqName)
 }

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

@@ -64,5 +64,5 @@ class JavaSymbolProvider(
     override fun getTopLevelPropertySymbolsTo(destination: MutableList<FirPropertySymbol>, packageFqName: FqName, name: Name) {}
 }
 
-val FirSession.javaSymbolProvider: JavaSymbolProvider by FirSession.sessionComponentAccessor()
+val FirSession.javaSymbolProvider: JavaSymbolProvider? by FirSession.nullableSessionComponentAccessor()
 

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

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSessionComponent
 
 class FirJvmDefaultModeComponent(val jvmDefaultMode: JvmDefaultMode) : FirSessionComponent
 
-private val FirSession.jvmDefaultModeComponent: FirJvmDefaultModeComponent by FirSession.sessionComponentAccessor()
+private val FirSession.jvmDefaultModeComponent: FirJvmDefaultModeComponent? by FirSession.nullableSessionComponentAccessor()
 
-val FirSession.jvmDefaultModeState: JvmDefaultMode
+val FirSession.jvmDefaultModeState: JvmDefaultMode?
-    get() = jvmDefaultModeComponent.jvmDefaultMode
+    get() = jvmDefaultModeComponent?.jvmDefaultMode

compiler/testData/cli/metadata/optionalAnnotationsFromMetadata.args

@@ -0,0 +1,5 @@
+$TESTDATA_DIR$/optionalAnnotationsFromMetadata.kt
+-d
+$TEMP_DIR$
+-cp
+$TESTDATA_DIR$/../../../../dist/common/kotlin-stdlib-common.jar

compiler/testData/cli/metadata/optionalAnnotationsFromMetadata.kt

@@ -0,0 +1,10 @@
+import kotlin.math.*
+import kotlin.js.*
+import kotlin.Result.Companion.success
+
+fun f(x: Int) = abs(x)
+
+@JsName("test")
+public class C
+
+fun g() = success(true)

compiler/testData/cli/metadata/optionalAnnotationsFromMetadata.out

@@ -0,0 +1 @@
+OK

compiler/testData/cli/metadata/optionalAnnotationsFromMetadataWithFir.args

@@ -0,0 +1,7 @@
+$TESTDATA_DIR$/optionalAnnotationsFromMetadata.kt
+-d
+$TEMP_DIR$
+-cp
+$TESTDATA_DIR$/../../../../dist/common/kotlin-stdlib-common.jar
+-language-version
+2.0

compiler/testData/cli/metadata/optionalAnnotationsFromMetadataWithFir.out

@@ -0,0 +1,2 @@
+warning: language version 2.0 is experimental, there are no backwards compatibility guarantees for new language and library features
+OK

compiler/tests-gen/org/jetbrains/kotlin/cli/CliTestGenerated.java

@@ -1629,6 +1629,16 @@ public class CliTestGenerated extends AbstractCliTest {
             runTest("compiler/testData/cli/metadata/moduleNameWithFir.args");
         }
 
+        @TestMetadata("optionalAnnotationsFromMetadata.args")
+        public void testOptionalAnnotationsFromMetadata() throws Exception {
+            runTest("compiler/testData/cli/metadata/optionalAnnotationsFromMetadata.args");
+        }
+
+        @TestMetadata("optionalAnnotationsFromMetadataWithFir.args")
+        public void testOptionalAnnotationsFromMetadataWithFir() throws Exception {
+            runTest("compiler/testData/cli/metadata/optionalAnnotationsFromMetadataWithFir.args");
+        }
+
         @TestMetadata("optionalExpectationUsage.args")
         public void testOptionalExpectationUsage() throws Exception {
             runTest("compiler/testData/cli/metadata/optionalExpectationUsage.args");