[K/N] KFC-446: K2 platform: Native alpha

Merge-request: KT-MR-7905
Merged-by: Vladimir Sukharev <Vladimir.Sukharev@jetbrains.com>

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

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2010-2022 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.
+ */
+
+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.checkers.registerNativeCheckers
+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.scopes.FirKotlinScopeProvider
+import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
+import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary
+import org.jetbrains.kotlin.name.Name
+
+object FirNativeSessionFactory : FirAbstractSessionFactory() {
+    fun createLibrarySession(
+        mainModuleName: Name,
+        resolvedLibraries: List<KotlinResolvedLibrary>,
+        sessionProvider: FirProjectSessionProvider,
+        dependencyListForCliModule: DependencyListForCliModule,
+        languageVersionSettings: LanguageVersionSettings,
+        registerExtraComponents: ((FirSession) -> Unit) = {},
+    ): FirSession {
+        val moduleDataProvider = dependencyListForCliModule.moduleDataProvider
+        return createLibrarySession(
+            mainModuleName,
+            sessionProvider,
+            moduleDataProvider,
+            languageVersionSettings,
+            registerExtraComponents,
+            createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _ -> declaredMemberScope } },
+            createProviders = { session, builtinsModuleData, kotlinScopeProvider ->
+                listOf(
+                    KlibBasedSymbolProvider(session, moduleDataProvider, kotlinScopeProvider, resolvedLibraries),
+                    FirBuiltinSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
+                    FirCloneableSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
+                )
+            })
+    }
+
+    fun createModuleBasedSession(
+        moduleData: FirModuleData,
+        sessionProvider: FirProjectSessionProvider,
+        extensionRegistrars: List<FirExtensionRegistrar>,
+        languageVersionSettings: LanguageVersionSettings,
+        init: FirSessionConfigurator.() -> Unit,
+        registerExtraComponents: ((FirSession) -> Unit) = {},
+    ): FirSession {
+        return createModuleBasedSession(
+            moduleData,
+            sessionProvider,
+            extensionRegistrars,
+            languageVersionSettings,
+            null,
+            null,
+            init,
+            registerExtraComponents = { session ->
+                session.registerExtraComponentsForModuleBased()
+                registerExtraComponents(session)
+            },
+            registerExtraCheckers = { it.registerNativeCheckers() },
+            createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _ -> declaredMemberScope } },
+            createProviders = { _, _, symbolProvider, generatedSymbolsProvider, dependenciesSymbolProvider ->
+                listOfNotNull(
+                    symbolProvider,
+                    generatedSymbolsProvider,
+                    dependenciesSymbolProvider,
+                )
+            }
+        )
+    }
+
+    @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())
+    }
+}

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2022 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.
+ */
+
+package org.jetbrains.kotlin.fir.session
+
+import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
+import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
+import org.jetbrains.kotlin.fir.resolve.calls.ConeCompositeConflictResolver
+import org.jetbrains.kotlin.fir.resolve.calls.ConeIntegerOperatorConflictResolver
+import org.jetbrains.kotlin.fir.resolve.calls.ConeOverloadConflictResolver
+import org.jetbrains.kotlin.fir.resolve.calls.jvm.ConeEquivalentCallConflictResolver
+import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
+import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
+
+object NativeCallConflictResolverFactory : ConeCallConflictResolverFactory() {
+    override fun create(
+        typeSpecificityComparator: TypeSpecificityComparator,
+        components: InferenceComponents,
+        transformerComponents: BodyResolveComponents
+    ): ConeCompositeConflictResolver {
+        val specificityComparator = TypeSpecificityComparator.NONE
+        return ConeCompositeConflictResolver(
+            ConeOverloadConflictResolver(specificityComparator, components, transformerComponents),
+            ConeEquivalentCallConflictResolver(specificityComparator, components, transformerComponents),
+            ConeIntegerOperatorConflictResolver(specificityComparator, components, transformerComponents)
+        )
+    }
+}

compiler/fir/fir-serialization/build.gradle.kts

@@ -8,6 +8,7 @@ dependencies {
     implementation(project(":core:compiler.common.jvm"))
     implementation(project(":core:deserialization.common.jvm"))
     implementation(project(":compiler:fir:fir-deserialization"))
+    implementation(project(":compiler:ir.serialization.common"))
 
     api(project(":compiler:fir:cones"))
     api(project(":compiler:fir:tree"))

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/firKlibSerialization.kt

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2010-2022 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.
+ */
+
+package org.jetbrains.kotlin.fir.serialization
+
+import org.jetbrains.kotlin.backend.common.serialization.metadata.buildKlibPackageFragment
+import org.jetbrains.kotlin.builtins.StandardNames
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.utils.classId
+import org.jetbrains.kotlin.fir.packageFqName
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.serialization.SerializableStringTable
+
+fun serializeSingleFirFile(file: FirFile, session: FirSession, scopeSession: ScopeSession, metadataVersion: BinaryVersion): ProtoBuf.PackageFragment {
+    val serializerExtension = FirKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable())
+    val approximator = TypeApproximatorForMetadataSerializer(session)
+    val packageSerializer = FirElementSerializer.createTopLevel(session, scopeSession, serializerExtension, approximator)
+
+    // TODO: typealiases (see klib serializer)
+    // TODO: split package fragment (see klib serializer)
+    // TODO: handle incremental/monolothic (see klib serializer) - maybe externally
+
+    val packageProto = packageSerializer.packagePartProto(file.packageFqName, file).build()
+
+    fun List<FirDeclaration>.makeClassesProtoWithNested(): List<Pair<ProtoBuf.Class, Int>> =
+        // TODO: filter out expects
+        filterIsInstance<FirClass>().sortedBy { it.classId.asFqNameString() }.flatMap {
+            val classSerializer = FirElementSerializer.create(session, scopeSession, it, serializerExtension, null, approximator)
+            val index = classSerializer.stringTable.getFqNameIndex(it)
+            listOf(classSerializer.classProto(it).build() to index) + it.declarations.makeClassesProtoWithNested()
+        }
+
+    val classesProto = file.declarations.makeClassesProtoWithNested()
+
+    val hasTopLevelDeclarations = file.declarations.any {
+        it is FirProperty || it is FirSimpleFunction || it is FirTypeAlias
+    }
+
+    return buildKlibPackageFragment(
+        packageProto,
+        classesProto,
+        file.packageFqName,
+        hasTopLevelDeclarations && classesProto.isEmpty(),
+        serializerExtension.stringTable as SerializableStringTable
+    )
+}
+
+class FirKLibSerializerExtension(
+    override val session: FirSession,
+    override val metadataVersion: BinaryVersion,
+    override val stringTable: FirElementAwareSerializableStringTable
+) : FirSerializerExtension() {
+    override fun shouldSerializeFunction(function: FirFunction): Boolean = true
+
+    override fun shouldSerializeProperty(property: FirProperty): Boolean = true
+}
+
+class FirElementAwareSerializableStringTable() : FirElementAwareStringTable, SerializableStringTable() {
+    override fun getLocalClassIdReplacement(firClass: FirClass): ClassId? = ClassId.topLevel(StandardNames.FqNames.any.toSafe())
+}