[FIR/Native] Move fir-related code from backend.native module to new one

^KT-61249

build.gradle.kts

@@ -155,6 +155,7 @@ val firCompilerCoreModules = arrayOf(
     ":compiler:fir:plugin-utils",
     ":compiler:fir:tree",
     ":compiler:fir:java",
+    ":compiler:fir:native",
     ":compiler:fir:raw-fir:raw-fir.common",
     ":compiler:fir:raw-fir:psi2fir",
     ":compiler:fir:checkers",

compiler/fir/native/build.gradle.kts

@@ -0,0 +1,18 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    implementation(project(":core:compiler.common.native"))
+    implementation(project(":compiler:frontend.common"))
+    implementation(project(":compiler:fir:resolve"))
+    implementation(project(":compiler:fir:fir2ir"))
+    implementation(project(":compiler:ir.serialization.common"))
+}
+
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" {}
+}

compiler/fir/native/src/org/jetbrains/kotlin/fir/backend/native/FirNativeKotlinMangler.kt

@@ -3,7 +3,7 @@
  * 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.backend.konan
+package org.jetbrains.kotlin.fir.backend.native
 
 import org.jetbrains.kotlin.backend.common.serialization.mangle.KotlinExportChecker
 import org.jetbrains.kotlin.backend.common.serialization.mangle.KotlinMangleComputer
@@ -13,16 +13,18 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.backend.FirMangler
 import org.jetbrains.kotlin.fir.backend.FirExportCheckerVisitor
 import org.jetbrains.kotlin.fir.backend.FirMangleComputer
+import org.jetbrains.kotlin.fir.backend.native.interop.*
+import org.jetbrains.kotlin.fir.backend.native.interop.hasObjCFactoryAnnotation
+import org.jetbrains.kotlin.fir.backend.native.interop.hasObjCMethodAnnotation
+import org.jetbrains.kotlin.fir.backend.native.interop.isObjCClassMethod
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.isSubstitutionOrIntersectionOverride
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.types.toSymbol
-import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.NativeRuntimeNames
-import org.jetbrains.kotlin.name.FqName
 
 class FirNativeKotlinMangler : FirMangler() {
     override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer<FirDeclaration> {
@@ -40,28 +42,26 @@ class FirNativeExportCheckerVisitor : FirExportCheckerVisitor() {
      * mimics AbstractKonanDescriptorMangler::DeclarationDescriptor.isPlatformSpecificExport()
      */
     override fun FirDeclaration.isPlatformSpecificExported(): Boolean {
-        fun List<FirAnnotation>.hasAnnotation(fqName: FqName) = hasAnnotation(ClassId.topLevel(fqName), moduleData.session)
-
         if (this is FirCallableDeclaration && isSubstitutionOrIntersectionOverride)
             return false
 
-        if (annotations.hasAnnotation(RuntimeNames.symbolNameAnnotation)) {
+        if (annotations.hasAnnotation(NativeRuntimeNames.Annotations.symbolNameClassId, moduleData.session)) {
             // Treat any `@SymbolName` declaration as exported.
             return true
         }
-        if (annotations.hasAnnotation(KonanFqNames.gcUnsafeCall)) {
+        if (annotations.hasAnnotation(NativeRuntimeNames.Annotations.gcUnsafeCallClassId, moduleData.session)) {
             // Treat any `@GCUnsafeCall` declaration as exported.
             return true
         }
-        if (annotations.hasAnnotation(RuntimeNames.exportForCppRuntime)) {
+        if (annotations.hasAnnotation(NativeRuntimeNames.Annotations.exportForCppRuntimeClassId, moduleData.session)) {
             // Treat any `@ExportForCppRuntime` declaration as exported.
             return true
         }
-        if (annotations.hasAnnotation(RuntimeNames.cnameAnnotation)) {
+        if (annotations.hasAnnotation(NativeRuntimeNames.Annotations.cNameClassId, moduleData.session)) {
             // Treat `@CName` declaration as exported.
             return true
         }
-        if (annotations.hasAnnotation(RuntimeNames.exportForCompilerAnnotation)) {
+        if (annotations.hasAnnotation(NativeRuntimeNames.Annotations.exportForCompilerClassId, moduleData.session)) {
             return true
         }
 

compiler/fir/native/src/org/jetbrains/kotlin/fir/backend/native/FirNativeOverrideChecker.kt

@@ -3,9 +3,11 @@
  * 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.backend.konan
+package org.jetbrains.kotlin.fir.backend.native
 
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.backend.native.interop.decodeObjCMethodAnnotation
+import org.jetbrains.kotlin.fir.backend.native.interop.isExternalObjCClassProperty
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction

compiler/fir/native/src/org/jetbrains/kotlin/fir/backend/native/interop/FirObjCInterop.kt

@@ -3,10 +3,9 @@
  * 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.backend.konan
+package org.jetbrains.kotlin.fir.backend.native.interop
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
 import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
@@ -26,16 +25,11 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.types.classId
-import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.NativeStandardInteropNames
+import org.jetbrains.kotlin.native.interop.ObjCMethodInfo
 import org.jetbrains.kotlin.utils.DFS
 
-private val objCDirectClassId = ClassId.topLevel(objCDirectFqName)
-private val objCMethodClassId = ClassId.topLevel(objCMethodFqName)
-private val objCObjectClassId = ClassId.topLevel(objCObjectFqName)
-private val objCFactoryClassId = ClassId.topLevel(objCFactoryFqName)
-private val objCConstructorClassId = ClassId.topLevel(objCConstructorFqName)
-private val externalObjCClassClassId = ClassId.topLevel(externalObjCClassFqName)
 
 @OptIn(SymbolInternals::class)
 internal fun FirFunction.getObjCMethodInfoFromOverriddenFunctions(session: FirSession, scopeSession: ScopeSession): ObjCMethodInfo? {
@@ -65,7 +59,7 @@ internal fun FirFunction.getObjCMethodInfoFromOverriddenFunctions(session: FirSe
  */
 @OptIn(SymbolInternals::class)
 private fun FirConstructor.getObjCInitMethod(session: FirSession, scopeSession: ScopeSession): FirFunction? {
-    this.annotations.getAnnotationByClassId(objCConstructorClassId, session)?.let { annotation ->
+    this.annotations.getAnnotationByClassId(NativeStandardInteropNames.objCConstructorClassId, session)?.let { annotation ->
         val initSelector: String = annotation.constStringArgument("initSelector")
         val classSymbol = containingClassLookupTag()?.toSymbol(session) as FirClassSymbol<*>
         val initSelectors = mutableListOf<FirFunction>()
@@ -84,12 +78,12 @@ private fun FirConstructor.getObjCInitMethod(session: FirSession, scopeSession:
  * mimics FunctionDescriptor.decodeObjCMethodAnnotation()
  */
 internal fun FirFunction.decodeObjCMethodAnnotation(session: FirSession): ObjCMethodInfo? =
-        annotations.getAnnotationByClassId(objCMethodClassId, session)?.let {
+        annotations.getAnnotationByClassId(NativeStandardInteropNames.objCMethodClassId, session)?.let {
             ObjCMethodInfo(
                     selector = it.constStringArgument("selector"),
                     encoding = it.constStringArgument("encoding"),
                     isStret = it.constBooleanArgumentOrNull("isStret") ?: false,
-                    directSymbol = annotations.getAnnotationByClassId(objCDirectClassId, session)?.constStringArgument("symbol"),
+                    directSymbol = annotations.getAnnotationByClassId(NativeStandardInteropNames.objCDirectClassId, session)?.constStringArgument("symbol"),
             )
         }
 
@@ -103,9 +97,9 @@ private fun FirAnnotation.constBooleanArgumentOrNull(argumentName: String): Bool
 private fun FirAnnotation.constArgument(argumentName: String) =
         (argumentMapping.mapping[Name.identifier(argumentName)] as? FirConstExpression<*>)?.value
 
-internal fun FirFunction.hasObjCFactoryAnnotation(session: FirSession) = this.annotations.hasAnnotation(objCFactoryClassId, session)
+internal fun FirFunction.hasObjCFactoryAnnotation(session: FirSession) = this.annotations.hasAnnotation(NativeStandardInteropNames.objCFactoryClassId, session)
 
-internal fun FirFunction.hasObjCMethodAnnotation(session: FirSession) = this.annotations.hasAnnotation(objCMethodClassId, session)
+internal fun FirFunction.hasObjCMethodAnnotation(session: FirSession) = this.annotations.hasAnnotation(NativeStandardInteropNames.objCMethodClassId, session)
 
 /**
  * almost mimics FunctionDescriptor.isObjCClassMethod(), apart from `it.isObjCClass()` changed to `it.symbol.isObjCClass(session)` for simplicity
@@ -117,14 +111,14 @@ internal fun FirFunction.isObjCClassMethod(session: FirSession) =
  * mimics ConstructorDescriptor.isObjCConstructor()
  */
 internal fun FirConstructor.isObjCConstructor(session: FirSession) =
-        this.annotations.hasAnnotation(objCConstructorClassId, session)
+        this.annotations.hasAnnotation(NativeStandardInteropNames.objCConstructorClassId, session)
 
 /**
  * mimics IrClass.isObjCClass()
  */
-private fun FirClassSymbol<*>.isObjCClass(session: FirSession) = classId.packageFqName != interopPackageName &&
+private fun FirClassSymbol<*>.isObjCClass(session: FirSession) = classId.packageFqName != NativeStandardInteropNames.cInteropPackage &&
         selfOrAnySuperClass(session) {
-            it.classId == objCObjectClassId
+            it.classId == NativeStandardInteropNames.objCObjectClassId
         }
 
 /**
@@ -148,12 +142,12 @@ internal fun FirFunction.getInitMethodIfObjCConstructor(session: FirSession, sco
             this
 
 internal fun FirProperty.isExternalObjCClassProperty(session: FirSession) =
-        (getContainingClassSymbol(session) as? FirClassSymbol)?.isExternalObjCClass(session) == true
+        (containingClassLookupTag()?.toSymbol(session) as? FirClassSymbol)?.isExternalObjCClass(session) == true
 
 internal fun FirClassSymbol<*>.isExternalObjCClass(session: FirSession): Boolean =
         isObjCClass(session) &&
                 parentsWithSelf(session).filterIsInstance<FirClass>().any {
-                    it.hasAnnotation(externalObjCClassClassId, session)
+                    it.hasAnnotation(NativeStandardInteropNames.externalObjCClassClassId, session)
                 }
 
 @OptIn(SymbolInternals::class)

core/compiler.common.native/src/org/jetbrains/kotlin/name/NativeRuntimeNames.kt

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2010-2023 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.name
+
+object NativeRuntimeNames {
+    private val kotlinNativePackage = FqName("kotlin.native")
+    private val kotlinNativeInternalPackage = kotlinNativePackage.child(Name.identifier("internal"))
+    object Annotations {
+        val symbolNameClassId = ClassId(kotlinNativePackage, Name.identifier("SymbolName"))
+        val cNameClassId = ClassId(kotlinNativePackage, Name.identifier("CName"))
+        val exportForCppRuntimeClassId = ClassId(kotlinNativeInternalPackage, Name.identifier("ExportForCppRuntime"))
+        val exportForCompilerClassId = ClassId(kotlinNativeInternalPackage, Name.identifier("ExportForCompiler"))
+        val gcUnsafeCallClassId = ClassId(kotlinNativeInternalPackage, Name.identifier("GCUnsafeCall"))
+    }
+}

core/compiler.common.native/src/org/jetbrains/kotlin/name/NativeStandardInteropNames.kt

@@ -14,6 +14,14 @@ object NativeStandardInteropNames {
     internal val ObjCObject = Name.identifier("ObjCObject")
     val ExperimentalForeignApi = Name.identifier("ExperimentalForeignApi")
 
+    val objCDirectClassId = ClassId(cInteropPackage, Name.identifier("ObjCDirect"))
+    val objCMethodClassId = ClassId(cInteropPackage, Name.identifier("ObjCMethod"))
+    val objCObjectClassId = ClassId(cInteropPackage, Name.identifier("ObjCObject"))
+    val objCFactoryClassId = ClassId(cInteropPackage, Name.identifier("ObjCFactory"))
+    val objCConstructorClassId = ClassId(cInteropPackage, Name.identifier("ObjCConstructor"))
+    val externalObjCClassClassId = ClassId(cInteropPackage, Name.identifier("ExternalObjCClass"))
+
+
     object ForwardDeclarations {
         private val cNamesPackage = FqName("cnames")
         val cNamesStructsPackage = cNamesPackage.child(Name.identifier("structs"))

core/compiler.common.native/src/org/jetbrains/kotlin/native/interop/ObjCMethodInfo.kt

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2010-2023 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.native.interop
+
+data class ObjCMethodInfo(val selector: String,
+                          val encoding: String,
+                          val isStret: Boolean,
+                          val directSymbol: String?)

kotlin-native/backend.native/build.gradle

@@ -171,6 +171,7 @@ dependencies {
     compilerApi project(":kotlin-util-klib-metadata")
     compilerApi project(":compiler:ir.serialization.common")
     compilerApi project(":compiler:fir:fir-serialization")
+    compilerApi project(":compiler:fir:native")
     compilerApi project(":compiler:ir.psi2ir")
     compilerApi project(":kotlin-native-shared")
     use(IntellijDependenciesKt) {

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Fir2Ir.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.descriptors.isEmpty
 import org.jetbrains.kotlin.descriptors.konan.isNativeStdlib
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.fir.backend.*
+import org.jetbrains.kotlin.fir.backend.native.FirNativeKotlinMangler
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
 import org.jetbrains.kotlin.fir.pipeline.convertToIrAndActualize
 import org.jetbrains.kotlin.fir.signaturer.Ir2FirManglerAdapter

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/FirFrontend.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticsCollector
 import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.backend.native.FirNativeOverrideChecker
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.pipeline.FirResult
 import org.jetbrains.kotlin.fir.pipeline.ModuleCompilerAnalyzedOutput

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanFqNames.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.backend.konan
 
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.NativeRuntimeNames
 
 internal const val NATIVE_PTR_NAME = "NativePtr"
 internal const val NON_NULL_NATIVE_PTR_NAME = "NonNullNativePtr"
@@ -34,7 +35,7 @@ object KonanFqNames {
     val objCMethod = FqName("kotlinx.cinterop.ObjCMethod")
     val hasFinalizer = FqName("kotlin.native.internal.HasFinalizer")
     val hasFreezeHook = FqName("kotlin.native.internal.HasFreezeHook")
-    val gcUnsafeCall = FqName("kotlin.native.internal.GCUnsafeCall")
+    val gcUnsafeCall = NativeRuntimeNames.Annotations.gcUnsafeCallClassId.asSingleFqName()
     val eagerInitialization = FqName("kotlin.native.EagerInitialization")
     val noReorderFields = FqName("kotlin.native.internal.NoReorderFields")
     val objCName = FqName("kotlin.native.ObjCName")

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ObjCInterop.kt

@@ -20,6 +20,8 @@ import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.NativeForwardDeclarationKind
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.NativeStandardInteropNames
+import org.jetbrains.kotlin.native.interop.ObjCMethodInfo
 import org.jetbrains.kotlin.resolve.ExternalOverridabilityCondition
 import org.jetbrains.kotlin.resolve.constants.BooleanValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
@@ -30,14 +32,14 @@ import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.typeUtil.supertypes
 
 internal val interopPackageName = InteropFqNames.packageName
-internal val objCObjectFqName = interopPackageName.child(Name.identifier("ObjCObject"))
+internal val objCObjectFqName = NativeStandardInteropNames.objCObjectClassId.asSingleFqName()
 private val objCClassFqName = interopPackageName.child(Name.identifier("ObjCClass"))
 private val objCProtocolFqName = interopPackageName.child(Name.identifier("ObjCProtocol"))
-internal val externalObjCClassFqName = interopPackageName.child(Name.identifier("ExternalObjCClass"))
+internal val externalObjCClassFqName = NativeStandardInteropNames.externalObjCClassClassId.asSingleFqName()
-internal val objCDirectFqName = interopPackageName.child(Name.identifier("ObjCDirect"))
+internal val objCDirectFqName = NativeStandardInteropNames.objCDirectClassId.asSingleFqName()
-internal val objCMethodFqName = interopPackageName.child(Name.identifier("ObjCMethod"))
+internal val objCMethodFqName = NativeStandardInteropNames.objCMethodClassId.asSingleFqName()
-internal val objCConstructorFqName = FqName("kotlinx.cinterop.ObjCConstructor")
+internal val objCConstructorFqName = NativeStandardInteropNames.objCConstructorClassId.asSingleFqName()
-internal val objCFactoryFqName = interopPackageName.child(Name.identifier("ObjCFactory"))
+internal val objCFactoryFqName = NativeStandardInteropNames.objCFactoryClassId.asSingleFqName()
 
 fun ClassDescriptor.isObjCClass(): Boolean =
                 this.containingDeclaration.fqNameSafe != interopPackageName &&
@@ -112,11 +114,6 @@ fun ClassDescriptor.isKotlinObjCClass(): Boolean = this.isObjCClass() && !this.i
 fun IrClass.isKotlinObjCClass(): Boolean = this.isObjCClass() && !this.isExternalObjCClass()
 
 
-data class ObjCMethodInfo(val selector: String,
-                          val encoding: String,
-                          val isStret: Boolean,
-                          val directSymbol: String?)
-
 private fun FunctionDescriptor.decodeObjCMethodAnnotation(): ObjCMethodInfo? {
     assert (this.kind.isReal)
 

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/RuntimeNames.kt

@@ -1,13 +1,14 @@
 package org.jetbrains.kotlin.backend.konan
 
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.NativeRuntimeNames
 
 object RuntimeNames {
-    val symbolNameAnnotation = FqName("kotlin.native.SymbolName")
+    val symbolNameAnnotation = NativeRuntimeNames.Annotations.symbolNameClassId.asSingleFqName()
-    val cnameAnnotation = FqName("kotlin.native.CName")
+    val cnameAnnotation = NativeRuntimeNames.Annotations.cNameClassId.asSingleFqName()
     val frozenAnnotation = FqName("kotlin.native.internal.Frozen")
-    val exportForCppRuntime = FqName("kotlin.native.internal.ExportForCppRuntime")
+    val exportForCppRuntime = NativeRuntimeNames.Annotations.exportForCppRuntimeClassId.asSingleFqName()
-    val exportForCompilerAnnotation = FqName("kotlin.native.internal.ExportForCompiler")
+    val exportForCompilerAnnotation = NativeRuntimeNames.Annotations.exportForCompilerClassId.asSingleFqName()
     val exportTypeInfoAnnotation = FqName("kotlin.native.internal.ExportTypeInfo")
     val cCall = FqName("kotlinx.cinterop.internal.CCall")
     val cStructMemberAt = FqName("kotlinx.cinterop.internal.CStruct.MemberAt")

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt

@@ -51,6 +51,7 @@ import org.jetbrains.kotlin.konan.ForeignExceptionMode
 import org.jetbrains.kotlin.konan.library.KonanLibrary
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.native.interop.ObjCMethodInfo
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 

settings.gradle

@@ -291,6 +291,7 @@ include ":compiler:fir",
         ":compiler:fir:fir-serialization",
         ":compiler:fir:fir-deserialization",
         ":compiler:fir:java",
+        ":compiler:fir:native",
         ":compiler:fir:modularized-tests",
         ":compiler:fir:dump",
         ":compiler:fir:checkers",