Move FirJvmClassCodegen inside fir:fir2ir:jvm-backend #KT-38156 Fixed

This removes dependency of IR JVM backend from FIR

compiler/cli/build.gradle.kts

@@ -25,6 +25,7 @@ dependencies {
     compile(project(":compiler:fir:jvm"))
     compile(project(":compiler:fir:java"))
     compile(project(":compiler:fir:fir2ir"))
+    compile(project(":compiler:fir:fir2ir:jvm-backend"))
     compile(project(":compiler:fir:checkers"))
     compile(project(":kotlin-util-klib"))
     compile(project(":kotlin-util-io"))

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt

@@ -51,6 +51,7 @@ import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
+import org.jetbrains.kotlin.fir.backend.jvm.FirJvmClassCodegen
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
 import org.jetbrains.kotlin.fir.java.FirLibrarySession
@@ -76,7 +77,6 @@ import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import org.jetbrains.kotlin.utils.newLinkedHashMapWithExpectedSize
 import java.io.File
-import java.net.URLClassLoader
 
 object KotlinToJVMBytecodeCompiler {
     private fun writeOutput(
@@ -369,7 +369,11 @@ object KotlinToJVMBytecodeCompiler {
             val performanceManager = environment.configuration.get(CLIConfigurationKeys.PERF_MANAGER)
             performanceManager?.notifyGenerationStarted()
             generationState.beforeCompile()
-            codegenFactory.generateModuleInFrontendIRMode(generationState, moduleFragment, symbolTable, sourceManager)
+            codegenFactory.generateModuleInFrontendIRMode(
+                generationState, moduleFragment, symbolTable, sourceManager
+            ) { irClass, context, parentFunction ->
+                FirJvmClassCodegen(irClass, context, parentFunction, session)
+            }
             CodegenFactory.doCheckCancelled(generationState)
             generationState.factory.done()
             performanceManager?.notifyGenerationFinished(

compiler/fir/fir2ir/jvm-backend/build.gradle.kts

@@ -12,6 +12,7 @@ dependencies {
     compileOnly(project(":compiler:fir:fir-serialization"))
     compileOnly(project(":compiler:ir.tree"))
     compileOnly(project(":compiler:backend"))
+    compileOnly(project(":compiler:backend.jvm"))
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", "asm-all", rootProject = rootProject) }
 }

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmClassCodegen.kt

@@ -3,14 +3,20 @@
  * 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.jvm.codegen
+package org.jetbrains.kotlin.fir.backend.jvm
 
 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
+import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen
+import org.jetbrains.kotlin.backend.jvm.codegen.fileParent
+import org.jetbrains.kotlin.backend.jvm.codegen.mapClass
 import org.jetbrains.kotlin.backend.jvm.lower.MultifileFacadeFileEntry
-import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.AsmUtil
+import org.jetbrains.kotlin.codegen.MultifileClassCodegenImpl
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
+import org.jetbrains.kotlin.codegen.writeKotlinMetadata
+import org.jetbrains.kotlin.codegen.writeSyntheticClassMetadata
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.backend.FirMetadataSource
-import org.jetbrains.kotlin.fir.backend.jvm.FirJvmSerializerExtension
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
@@ -28,19 +34,17 @@ import org.jetbrains.kotlin.metadata.jvm.serialization.JvmStringTable
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.Method
 
-class FirBasedClassCodegen internal constructor(
+class FirJvmClassCodegen(
     irClass: IrClass,
     context: JvmBackendContext,
-    parentFunction: IrFunction? = null
+    parentFunction: IrFunction?,
+    session: FirSession,
 ) : ClassCodegen(irClass, context, parentFunction) {
-
-    private val session = (irClass.metadata as FirMetadataSource).session
-
     private val serializerExtension = FirJvmSerializerExtension(session, visitor.serializationBindings, state, irClass, typeMapper)
     private val serializer: FirElementSerializer? =
         when (val metadata = irClass.metadata) {
             is FirMetadataSource.Class -> FirElementSerializer.create(
-                metadata.klass, serializerExtension, (parentClassCodegen as? FirBasedClassCodegen)?.serializer
+                metadata.klass, serializerExtension, (parentClassCodegen as? FirJvmClassCodegen)?.serializer
             )
             is FirMetadataSource.File -> FirElementSerializer.createTopLevel(session, serializerExtension)
             is FirMetadataSource.Function -> FirElementSerializer.createForLambda(session, serializerExtension)

compiler/ir/backend.jvm/build.gradle.kts

@@ -5,9 +5,6 @@ plugins {
 
 dependencies {
     compile(project(":kotlin-annotations-jvm"))
-    compile(project(":compiler:fir:fir-serialization"))
-    compile(project(":compiler:fir:fir2ir"))
-    compile(project(":compiler:fir:fir2ir:jvm-backend"))
     compile(project(":compiler:backend"))
     compile(project(":compiler:ir.tree"))
     compile(project(":compiler:ir.psi2ir"))

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt

@@ -53,7 +53,8 @@ class JvmBackendContext(
     val phaseConfig: PhaseConfig,
     // If the JVM fqname of a class differs from what is implied by its parent, e.g. if it's a file class
     // annotated with @JvmPackageName, the correct name is recorded here.
-    internal val classNameOverride: MutableMap<IrClass, JvmClassName>
+    val classNameOverride: MutableMap<IrClass, JvmClassName>,
+    internal val createCodegen: (IrClass, JvmBackendContext, IrFunction?) -> ClassCodegen?,
 ) : CommonBackendContext {
     override val transformedFunction: MutableMap<IrFunctionSymbol, IrSimpleFunctionSymbol>
         get() = TODO("not implemented")
@@ -92,10 +93,10 @@ class JvmBackendContext(
 
     internal val classCodegens = mutableMapOf<IrClass, ClassCodegen>()
 
-    internal val localDelegatedProperties = mutableMapOf<IrClass, List<IrLocalDelegatedPropertySymbol>>()
+    val localDelegatedProperties = mutableMapOf<IrClass, List<IrLocalDelegatedPropertySymbol>>()
 
     internal val multifileFacadesToAdd = mutableMapOf<JvmClassName, MutableList<IrClass>>()
-    internal val multifileFacadeForPart = mutableMapOf<IrClass, JvmClassName>()
+    val multifileFacadeForPart = mutableMapOf<IrClass, JvmClassName>()
     internal val multifileFacadeClassForPart = mutableMapOf<IrClass, IrClass>()
     internal val multifileFacadeMemberToPartMember = mutableMapOf<IrFunction, IrFunction>()
 

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt

@@ -15,13 +15,12 @@ import org.jetbrains.kotlin.backend.jvm.serialization.JvmIdSignatureDescriptor
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.konan.DeserializedKlibModuleOrigin
 import org.jetbrains.kotlin.descriptors.konan.KlibModuleOrigin
-import org.jetbrains.kotlin.descriptors.konan.klibModuleOrigin
-import org.jetbrains.kotlin.descriptors.konan.kotlinLibrary
 import org.jetbrains.kotlin.idea.MainFunctionDetector
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.EmptyLoggingContext
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrLinker
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc
 import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.types.defaultType
 import org.jetbrains.kotlin.ir.util.*
@@ -86,10 +85,12 @@ object JvmBackendFacade {
         sourceManager: PsiSourceManager,
         phaseConfig: PhaseConfig,
         irProviders: List<IrProvider>,
-        extensions: JvmGeneratorExtensions
+        extensions: JvmGeneratorExtensions,
+        createCodegen: (IrClass, JvmBackendContext, IrFunction?) -> ClassCodegen? = { _, _, _ -> null },
     ) {
         val context = JvmBackendContext(
-            state, sourceManager, irModuleFragment.irBuiltins, irModuleFragment, symbolTable, phaseConfig, extensions.classNameOverride
+            state, sourceManager, irModuleFragment.irBuiltins, irModuleFragment,
+            symbolTable, phaseConfig, extensions.classNameOverride, createCodegen
         )
         /* JvmBackendContext creates new unbound symbols, have to resolve them. */
         ExternalDependenciesGenerator(symbolTable, irProviders, state.languageVersionSettings).generateUnboundSymbolsAsDependencies()

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt

@@ -17,12 +17,15 @@
 package org.jetbrains.kotlin.backend.jvm
 
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
+import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen
 import org.jetbrains.kotlin.codegen.CodegenFactory
 import org.jetbrains.kotlin.codegen.MultifileClassCodegen
 import org.jetbrains.kotlin.codegen.PackageCodegen
 import org.jetbrains.kotlin.codegen.PackageCodegenImpl
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.descriptors.WrappedDeclarationDescriptor
 import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
@@ -40,7 +43,11 @@ class JvmIrCodegenFactory(private val phaseConfig: PhaseConfig) : CodegenFactory
     }
 
     fun generateModuleInFrontendIRMode(
-        state: GenerationState, irModuleFragment: IrModuleFragment, symbolTable: SymbolTable, sourceManager: PsiSourceManager
+        state: GenerationState,
+        irModuleFragment: IrModuleFragment,
+        symbolTable: SymbolTable,
+        sourceManager: PsiSourceManager,
+        createCodegen: (IrClass, JvmBackendContext, IrFunction?) -> ClassCodegen?,
     ) {
         val extensions = JvmGeneratorExtensions()
         val irProviders = generateTypicalIrProviderList(
@@ -55,7 +62,7 @@ class JvmIrCodegenFactory(private val phaseConfig: PhaseConfig) : CodegenFactory
         }
 
         JvmBackendFacade.doGenerateFilesInternal(
-            state, irModuleFragment, symbolTable, sourceManager, phaseConfig, irProviders, extensions
+            state, irModuleFragment, symbolTable, sourceManager, phaseConfig, irProviders, extensions, createCodegen
         )
     }
 

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt

@@ -12,11 +12,9 @@ import org.jetbrains.kotlin.backend.jvm.lower.buildAssertionsDisabledField
 import org.jetbrains.kotlin.backend.jvm.lower.hasAssertionsDisabledField
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.inline.*
-import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.backend.FirMetadataSource
 import org.jetbrains.kotlin.ir.builders.declarations.buildFun
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.descriptors.WrappedClassDescriptor
@@ -28,7 +26,6 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrSetFieldImpl
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.types.IrSimpleType
 import org.jetbrains.kotlin.ir.util.*
-import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.annotations.JVM_SYNTHETIC_ANNOTATION_FQ_NAME
@@ -44,9 +41,9 @@ import org.jetbrains.org.objectweb.asm.tree.MethodNode
 import java.io.File
 
 abstract class ClassCodegen protected constructor(
-    internal val irClass: IrClass,
+    val irClass: IrClass,
     val context: JvmBackendContext,
-    private val parentFunction: IrFunction? = null
+    private val parentFunction: IrFunction?,
 ) : InnerClassConsumer {
     protected val parentClassCodegen = (parentFunction?.parentAsClass ?: irClass.parent as? IrClass)?.let { getOrCreate(it, context) }
     private val withinInline: Boolean = parentClassCodegen?.withinInline == true || parentFunction?.isInline == true
@@ -203,13 +200,13 @@ abstract class ClassCodegen protected constructor(
     }
 
     companion object {
-        fun getOrCreate(irClass: IrClass, context: JvmBackendContext, parentFunction: IrFunction? = null): ClassCodegen =
+        fun getOrCreate(
+            irClass: IrClass,
+            context: JvmBackendContext,
+            parentFunction: IrFunction? = null,
+        ): ClassCodegen =
             context.classCodegens.getOrPut(irClass) {
-                if (irClass.metadata is FirMetadataSource) {
+                context.createCodegen(irClass, context, parentFunction) ?: DescriptorBasedClassCodegen(irClass, context, parentFunction)
-                    FirBasedClassCodegen(irClass, context, parentFunction)
-                } else {
-                    DescriptorBasedClassCodegen(irClass, context, parentFunction)
-                }
             }.also {
                 assert(parentFunction == null || it.parentFunction == parentFunction) {
                     "inconsistent parent function for ${irClass.render()}:\n" +

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/DescriptorBasedClassCodegen.kt

@@ -26,7 +26,7 @@ import org.jetbrains.org.objectweb.asm.commons.Method
 class DescriptorBasedClassCodegen internal constructor(
     irClass: IrClass,
     context: JvmBackendContext,
-    parentFunction: IrFunction? = null
+    parentFunction: IrFunction?,
 ) : ClassCodegen(irClass, context, parentFunction) {
 
     private val serializerExtension = JvmSerializerExtension(visitor.serializationBindings, state, typeMapper)

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt

@@ -68,7 +68,7 @@ fun IrFrameMap.leave(irDeclaration: IrSymbolOwner): Int {
 
 val IrClass.isJvmInterface get() = isAnnotationClass || isInterface
 
-internal val IrDeclaration.fileParent: IrFile
+val IrDeclaration.fileParent: IrFile
     get() {
         val myParent = parent
         return when (myParent) {

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt

@@ -76,7 +76,7 @@ internal val generateMultifileFacadesPhase = namedIrModulePhase(
     }
 )
 
-internal class MultifileFacadeFileEntry(
+class MultifileFacadeFileEntry(
     private val className: JvmClassName,
     val partFiles: List<IrFile>
 ) : SourceManager.FileEntry {

compiler/tests-common/build.gradle.kts

@@ -17,6 +17,7 @@ dependencies {
     testCompile(project(":compiler:fir:fir2ir"))
     testCompile(project(":compiler:fir:jvm"))
     testCompile(project(":compiler:fir:fir2ir:jvm-backend"))
+    testCompile(project(":compiler:fir:fir-serialization"))
     testCompile(project(":compiler:fir:cones"))
     testCompile(project(":compiler:fir:resolve"))
     testCompile(project(":compiler:fir:checkers"))

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt

@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
+import org.jetbrains.kotlin.fir.backend.jvm.FirJvmClassCodegen
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.createSession
 import org.jetbrains.kotlin.fir.resolve.firProvider
@@ -49,6 +50,7 @@ import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
 import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc
+import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.AnalyzingUtils
@@ -163,7 +165,12 @@ object GenerationUtils {
         ).build()
 
         generationState.beforeCompile()
-        codegenFactory.generateModuleInFrontendIRMode(generationState, moduleFragment, symbolTable, sourceManager)
+        codegenFactory.generateModuleInFrontendIRMode(
+            generationState, moduleFragment, symbolTable, sourceManager
+        ) { irClass, context, irFunction ->
+            FirJvmClassCodegen(irClass, context, irFunction, session)
+        }
+
         generationState.factory.done()
         return generationState
     }