[K2/N] KT-55598: Run special backend checks in K2/Native pipeline

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

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

@@ -6,6 +6,8 @@ import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDe
 import org.jetbrains.kotlin.backend.konan.driver.PhaseContext
 import org.jetbrains.kotlin.backend.konan.driver.phases.Fir2IrOutput
 import org.jetbrains.kotlin.backend.konan.driver.phases.FirOutput
+import org.jetbrains.kotlin.backend.konan.ir.KonanSymbolsOverFir
+import org.jetbrains.kotlin.backend.konan.serialization.KonanIdSignaturer
 import org.jetbrains.kotlin.backend.konan.serialization.KonanManglerDesc
 import org.jetbrains.kotlin.backend.konan.serialization.KonanManglerIr
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
@@ -15,9 +17,7 @@ import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.deserialization.PlatformDependentTypeTransformer
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
+import org.jetbrains.kotlin.fir.backend.*
-import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions
-import org.jetbrains.kotlin.fir.backend.Fir2IrVisibilityConverter
 import org.jetbrains.kotlin.fir.backend.jvm.Fir2IrJvmSpecialAnnotationSymbolProvider
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
+import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.library.metadata.KlibMetadataFactories
 import org.jetbrains.kotlin.library.unresolvedDependencies
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
@@ -82,6 +83,17 @@ internal fun PhaseContext.fir2Ir(
         (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = librariesDescriptors }
     }
 
+    val symbols = createKonanSymbols(fir2irResult)
     // TODO KT-55580 Invoke CopyDefaultValuesToActualPhase, same as PsiToir phase does.
-    return Fir2IrOutput(input.session, input.scopeSession, input.firFiles, fir2irResult)
+    return Fir2IrOutput(input.session, input.scopeSession, input.firFiles, fir2irResult, symbols)
+}
+
+private fun PhaseContext.createKonanSymbols(
+        fir2irResult: Fir2IrResult,
+): KonanSymbolsOverFir {
+    val moduleDescriptor = fir2irResult.irModuleFragment.descriptor
+    val symbolTable = SymbolTable(KonanIdSignaturer(KonanManglerDesc), fir2irResult.pluginContext.irFactory)
+    val descriptorsLookup = DescriptorsLookup(moduleDescriptor.builtIns as KonanBuiltIns)
+
+    return KonanSymbolsOverFir(this, descriptorsLookup, fir2irResult.components.irBuiltIns, symbolTable, symbolTable.lazyWrapper)
 }

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

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.backend.konan.descriptors.isFromInteropLibrary
 import org.jetbrains.kotlin.backend.konan.driver.phases.PsiToIrContext
 import org.jetbrains.kotlin.backend.konan.driver.phases.PsiToIrInput
 import org.jetbrains.kotlin.backend.konan.driver.phases.PsiToIrOutput
-import org.jetbrains.kotlin.backend.konan.ir.KonanSymbols
+import org.jetbrains.kotlin.backend.konan.ir.KonanSymbolsOverDescriptors
 import org.jetbrains.kotlin.backend.konan.ir.interop.IrProviderForCEnumAndCStructStubs
 import org.jetbrains.kotlin.backend.konan.ir.konanLibrary
 import org.jetbrains.kotlin.backend.konan.serialization.*
@@ -90,7 +90,7 @@ internal fun PsiToIrContext.psiToIr(
                 BuiltInFictitiousFunctionIrClassFactory(symbolTable, irBuiltInsOverDescriptors, reflectionTypes)
     irBuiltInsOverDescriptors.functionFactory = functionIrClassFactory
     val descriptorsLookup = DescriptorsLookup(this.builtIns)
-    val symbols = KonanSymbols(this, descriptorsLookup, generatorContext.irBuiltIns, symbolTable, symbolTable.lazyWrapper)
+    val symbols = KonanSymbolsOverDescriptors(this, descriptorsLookup, generatorContext.irBuiltIns, symbolTable, symbolTable.lazyWrapper)
 
     val irDeserializer = if (isProducingLibrary && !useLinkerWhenProducingLibrary) {
         // Enable lazy IR generation for newly-created symbols inside BE

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

@@ -68,15 +68,13 @@ internal fun IrType.isObjCReferenceType(target: KonanTarget, irBuiltIns: IrBuilt
 
     if (isObjCObjectType()) return true
 
-    val descriptor = classifierOrNull?.descriptor ?: return false
+    return when (classifierOrNull) {
-    val builtIns = (irBuiltIns as IrBuiltInsOverDescriptors).builtIns
+        irBuiltIns.anyClass,
-
+        irBuiltIns.stringClass,
-    return when (descriptor) {
+        irBuiltIns.listClass,
-        builtIns.any,
+        irBuiltIns.mutableListClass,
-        builtIns.string,
+        irBuiltIns.setClass,
-        builtIns.list, builtIns.mutableList,
+        irBuiltIns.mapClass -> true
-        builtIns.set,
-        builtIns.map -> true
         else -> false
     }
 }

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

@@ -90,6 +90,7 @@ internal class DynamicCompilerDriver : CompilerDriver() {
         require(frontendOutput is FirOutput.Full)
 
         val fir2IrOutput = engine.runFir2Ir(frontendOutput)
+        engine.runK2SpecialBackendChecks(fir2IrOutput)
         return engine.runFirSerializer(fir2IrOutput)
     }
 

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/BackendPhases.kt

@@ -6,10 +6,12 @@
 package org.jetbrains.kotlin.backend.konan.driver.phases
 
 import org.jetbrains.kotlin.backend.common.lower
+import org.jetbrains.kotlin.backend.konan.InteropBuiltIns
 import org.jetbrains.kotlin.backend.konan.driver.PhaseContext
 import org.jetbrains.kotlin.backend.konan.driver.PhaseEngine
 import org.jetbrains.kotlin.backend.konan.lower.ExpectToActualDefaultValueCopier
 import org.jetbrains.kotlin.backend.konan.lower.SpecialBackendChecksTraversal
+import org.jetbrains.kotlin.builtins.konan.KonanBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 
 internal val SpecialBackendChecksPhase = createSimpleNamedCompilerPhase<PsiToIrContext, PsiToIrOutput>(
@@ -19,6 +21,18 @@ internal val SpecialBackendChecksPhase = createSimpleNamedCompilerPhase<PsiToIrC
     SpecialBackendChecksTraversal(context, context.interopBuiltIns, input.symbols, input.irModule.irBuiltins).lower(input.irModule)
 }
 
+internal val K2SpecialBackendChecksPhase = createSimpleNamedCompilerPhase<PhaseContext, Fir2IrOutput>(
+        "SpecialBackendChecks",
+        "Special backend checks",
+) { context, input ->
+    val moduleFragment = input.fir2irResult.irModuleFragment
+    SpecialBackendChecksTraversal(
+            context,
+            InteropBuiltIns(input.fir2irResult.pluginContext.moduleDescriptor.builtIns as KonanBuiltIns),
+            input.symbols,
+            moduleFragment.irBuiltins
+    ).lower(moduleFragment)
+}
 
 internal val CopyDefaultValuesToActualPhase = createSimpleNamedCompilerPhase<PhaseContext, IrModuleFragment>(
         name = "CopyDefaultValuesToActual",
@@ -29,4 +43,8 @@ internal val CopyDefaultValuesToActualPhase = createSimpleNamedCompilerPhase<Pha
 
 internal fun <T : PsiToIrContext> PhaseEngine<T>.runSpecialBackendChecks(psiToIrOutput: PsiToIrOutput) {
     runPhase(SpecialBackendChecksPhase, psiToIrOutput)
+}
+
+internal fun <T : PhaseContext> PhaseEngine<T>.runK2SpecialBackendChecks(fir2IrOutput: Fir2IrOutput) {
+    runPhase(K2SpecialBackendChecksPhase, fir2IrOutput)
 }

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

@@ -8,16 +8,18 @@ package org.jetbrains.kotlin.backend.konan.driver.phases
 import org.jetbrains.kotlin.backend.konan.driver.PhaseContext
 import org.jetbrains.kotlin.backend.konan.driver.PhaseEngine
 import org.jetbrains.kotlin.backend.konan.fir2Ir
+import org.jetbrains.kotlin.backend.konan.ir.KonanSymbols
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.backend.Fir2IrResult
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 
-data class Fir2IrOutput(
+internal data class Fir2IrOutput(
         val session: FirSession,
         val scopeSession: ScopeSession,
         val firFiles: List<FirFile>,
         val fir2irResult: Fir2IrResult,
+        val symbols: KonanSymbols
 )
 
 internal val Fir2IrPhase = createSimpleNamedCompilerPhase(

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

@@ -13,18 +13,23 @@ import org.jetbrains.kotlin.backend.konan.driver.PhaseContext
 import org.jetbrains.kotlin.backend.konan.llvm.findMainEntryPoint
 import org.jetbrains.kotlin.backend.konan.lower.TestProcessor
 import org.jetbrains.kotlin.builtins.StandardNames
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.fir.backend.IrBuiltInsOverFir
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.ir.IrBuiltIns
+import org.jetbrains.kotlin.ir.declarations.IrEnumEntry
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
+import org.jetbrains.kotlin.ir.declarations.IrProperty
+import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.defaultType
 import org.jetbrains.kotlin.ir.types.typeWith
 import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable
 import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.ir.util.constructors
+import org.jetbrains.kotlin.ir.util.findDeclaration
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi2ir.descriptors.IrBuiltInsOverDescriptors
@@ -40,13 +45,15 @@ internal class KonanIr(context: Context, irModule: IrModuleFragment): Ir<Context
     override var symbols: KonanSymbols by Delegates.notNull()
 }
 
-internal class KonanSymbols(
+internal abstract class KonanSymbols(
         context: PhaseContext,
         descriptorsLookup: DescriptorsLookup,
         irBuiltIns: IrBuiltIns,
-        private val symbolTable: SymbolTable,
+        internal val symbolTable: SymbolTable,
         lazySymbolTable: ReferenceSymbolTable
 ): Symbols(irBuiltIns, symbolTable) {
+    internal abstract fun IrClassSymbol.findMemberSimpleFunction(name: Name): IrSimpleFunctionSymbol?
+    internal abstract fun IrClassSymbol.findMemberPropertyGetter(name: Name): IrSimpleFunctionSymbol?
 
     val entryPoint = findMainEntryPoint(context, descriptorsLookup.builtIns)?.let { symbolTable.referenceSimpleFunction(it) }
 
@@ -82,7 +89,7 @@ internal class KonanSymbols(
             val symbol = if (fromClass in signedIntegerClasses && toClass in unsignedIntegerClasses) {
                 irBuiltIns.getNonBuiltInFunctionsByExtensionReceiver(name, "kotlin")[fromClass]!!
             } else {
-                irBuiltIns.findBuiltInClassMemberFunctions(fromClass, name).single()
+                fromClass.findMemberSimpleFunction(name)!!
             }
 
             (fromClass to toClass) to symbol
@@ -237,7 +244,7 @@ internal class KonanSymbols(
 
     val ieee754Equals = internalFunctions("ieee754Equals")
 
-    val equals = irBuiltIns.findBuiltInClassMemberFunctions(any, Name.identifier("equals")).single()
+    val equals = any.findMemberSimpleFunction(Name.identifier("equals"))!!
 
     val throwArithmeticException = internalFunction("ThrowArithmeticException")
 
@@ -294,14 +301,11 @@ internal class KonanSymbols(
     val copyInto = arrayToExtensionSymbolMap("copyInto")
     val copyOf = arrayToExtensionSymbolMap("copyOf") { it.valueParameters.isEmpty() }
 
-    val arrayGet = arrays.associateWith { irBuiltIns.findBuiltInClassMemberFunctions(it, Name.identifier("get")).single() }
+    val arrayGet = arrays.associateWith { it.findMemberSimpleFunction(Name.identifier("get"))!! }
 
-    val arraySet = arrays.associateWith { irBuiltIns.findBuiltInClassMemberFunctions(it, Name.identifier("set")).single() }
+    val arraySet = arrays.associateWith { it.findMemberSimpleFunction(Name.identifier("set"))!! }
-
-    val arraySize = arrays.associateWith { it.descriptor.unsubstitutedMemberScope
-                    .getContributedVariables(Name.identifier("size"), NoLookupLocation.FROM_BACKEND)
-                    .single().let { symbolTable.referenceSimpleFunction(it.getter!!) } }
 
+    val arraySize = arrays.associateWith { it.findMemberPropertyGetter(Name.identifier("size"))!! }
 
     val valuesForEnum = internalFunction("valuesForEnum")
 
@@ -317,7 +321,7 @@ internal class KonanSymbols(
     val initInstance = internalFunction("initInstance")
 
     val println = irBuiltIns.findFunctions(Name.identifier("println"), "kotlin", "io")
-            .single { it.descriptor.valueParameters.singleOrNull()?.type == (irBuiltIns as IrBuiltInsOverDescriptors).builtIns.stringType }
+            .single { it.descriptor.valueParameters.singleOrNull()?.type?.constructor?.declarationDescriptor == string.descriptor }
 
     override val getContinuation = internalFunction("getContinuation")
 
@@ -350,13 +354,9 @@ internal class KonanSymbols(
     val continuationImpl = internalCoroutinesClass("ContinuationImpl")
 
     val invokeSuspendFunction =
-            irBuiltIns.findBuiltInClassMemberFunctions(baseContinuationImpl, Name.identifier("invokeSuspend")).single()
+            baseContinuationImpl.findMemberSimpleFunction(Name.identifier("invokeSuspend"))!!
 
-    val completionGetter = symbolTable.referenceSimpleFunction(
+    val completionGetter = baseContinuationImpl.findMemberPropertyGetter(Name.identifier("completion"))!!
-            baseContinuationImpl.descriptor.unsubstitutedMemberScope
-                    .getContributedVariables(Name.identifier("completion"), NoLookupLocation.FROM_BACKEND).single()
-                    .getter!!
-    )
 
     override val coroutineSuspendedGetter = symbolTable.referenceSimpleFunction(
             coroutinesIntrinsicsPackage
@@ -455,15 +455,51 @@ internal class KonanSymbols(
 
     override val setWithoutBoundCheckName: Name? = KonanNameConventions.setWithoutBoundCheck
 
-    private val testFunctionKindCache = TestProcessor.FunctionKind.values().associate {
+    private val testFunctionKindCache by lazy {
-        val symbol = if (it.runtimeKindString.isEmpty())
+        TestProcessor.FunctionKind.values().associateWith { kind ->
-            null
+            if (kind.runtimeKindString.isEmpty())
-        else
+                null
-            symbolTable.referenceEnumEntry(testFunctionKind.descriptor.unsubstitutedMemberScope.getContributedClassifier(
+            else
-                    Name.identifier(it.runtimeKindString), NoLookupLocation.FROM_BACKEND
+                testFunctionKind.owner.declarations
-            ) as ClassDescriptor)
+                        .filterIsInstance<IrEnumEntry>()
-        it to symbol
+                        .single { it.name == Name.identifier(kind.runtimeKindString) }
+                        .symbol
+        }
     }
 
     fun getTestFunctionKind(kind: TestProcessor.FunctionKind) = testFunctionKindCache[kind]!!
 }
+
+internal class KonanSymbolsOverDescriptors(
+        context: PhaseContext,
+        descriptorsLookup: DescriptorsLookup,
+        irBuiltIns: IrBuiltIns,
+        symbolTable: SymbolTable,
+        lazySymbolTable: ReferenceSymbolTable
+) : KonanSymbols(context, descriptorsLookup, irBuiltIns, symbolTable, lazySymbolTable) {
+    override fun IrClassSymbol.findMemberSimpleFunction(name: Name): IrSimpleFunctionSymbol? =
+            // inspired by: irBuiltIns.findBuiltInClassMemberFunctions(this, name).singleOrNull()
+            descriptor.unsubstitutedMemberScope.getContributedFunctions(name, NoLookupLocation.FROM_BACKEND)
+                    .singleOrNull()
+                    ?.let { symbolTable.referenceSimpleFunction(it) }
+
+    override fun IrClassSymbol.findMemberPropertyGetter(name: Name): IrSimpleFunctionSymbol? =
+            descriptor.unsubstitutedMemberScope.getContributedVariables(name, NoLookupLocation.FROM_BACKEND)
+                    .singleOrNull()
+                    ?.getter
+                    ?.let { symbolTable.referenceSimpleFunction(it) }
+}
+
+internal class KonanSymbolsOverFir(
+        context: PhaseContext,
+        descriptorsLookup: DescriptorsLookup,
+        irBuiltIns: IrBuiltIns,
+        symbolTable: SymbolTable,
+        lazySymbolTable: ReferenceSymbolTable
+) : KonanSymbols(context, descriptorsLookup, irBuiltIns, symbolTable, lazySymbolTable) {
+    override fun IrClassSymbol.findMemberSimpleFunction(name: Name): IrSimpleFunctionSymbol? =
+            owner.findDeclaration<IrSimpleFunction> { it.name == name }?.symbol
+
+    override fun IrClassSymbol.findMemberPropertyGetter(name: Name): IrSimpleFunctionSymbol? =
+            owner.findDeclaration<IrProperty> { it.name == name }?.getter?.symbol
+}