[FIR] Drop using of JavaSymbolProvider and OptionalAnnotationClassesProvider in FirCommonSessionFactory

Drop using of all Java stuff inside FirCommonSessionFactory ^KT-56063
2023-02-23 16:43:05 +01:00
parent 4be359ba02
commit d829f8b684
17 changed files with 83 additions and 62 deletions
@@ -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
        )
@@ -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
 }

@@ -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
        )
@@ -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) {
@@ -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,
@@ -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.registerJavaSpecificResolveComponents()
+                it.registerDefaultExtraComponentsForModuleBased()
                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)
-            }
-        }
+        )
    }
 }
@@ -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.analysis.FirOverridesBackwardCompatibilityHelper
+import org.jetbrains.kotlin.fir.BinaryModuleData
+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.scopes.impl.FirEnumEntriesSupport
+import org.jetbrains.kotlin.fir.session.FirSessionFactoryHelper.registerDefaultExtraComponentsForModuleBased
 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))
-    }
 }
@@ -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))
+    }
 }
@@ -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)
 }
@@ -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()

@@ -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
-    get() = jvmDefaultModeComponent.jvmDefaultMode
+val FirSession.jvmDefaultModeState: JvmDefaultMode?
+    get() = jvmDefaultModeComponent?.jvmDefaultMode
@@ -0,0 +1,5 @@
+$TESTDATA_DIR$/optionalAnnotationsFromMetadata.kt
+-d
+$TEMP_DIR$
+-cp
+$TESTDATA_DIR$/../../../../dist/common/kotlin-stdlib-common.jar
@@ -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)
@@ -0,0 +1 @@
+OK
@@ -0,0 +1,7 @@
+$TESTDATA_DIR$/optionalAnnotationsFromMetadata.kt
+-d
+$TEMP_DIR$
+-cp
+$TESTDATA_DIR$/../../../../dist/common/kotlin-stdlib-common.jar
+-language-version
+2.0
@@ -0,0 +1,2 @@
+warning: language version 2.0 is experimental, there are no backwards compatibility guarantees for new language and library features
+OK
@@ -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");